"""
Adept MobileRobots Robotics Interface for Applications (ARIA)
Copyright (C) 2004-2005 ActivMedia Robotics LLC
Copyright (C) 2006-2010 MobileRobots Inc.
Copyright (C) 2011-2015 Adept Technology, Inc.
Copyright (C) 2016-2018 Omron Adept Technologies, Inc.

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
Adept MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
Adept MobileRobots, 10 Columbia Drive, Amherst, NH 03031; +1-603-881-7960
"""
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.




"""Python wrapper library for ArNetworking"""


from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_ArNetworkingPy', [dirname(__file__)])
        except ImportError:
            import _ArNetworkingPy
            return _ArNetworkingPy
        if fp is not None:
            try:
                _mod = imp.load_module('_ArNetworkingPy', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _ArNetworkingPy = swig_import_helper()
    del swig_import_helper
else:
    import _ArNetworkingPy
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


try:
    import weakref
    weakref_proxy = weakref.proxy
except Exception:
    weakref_proxy = lambda x: x


import AriaPy

_ArNetworkingPy.SWIG_IMPORTED_ARIA_swigconstant(_ArNetworkingPy)
SWIG_IMPORTED_ARIA = _ArNetworkingPy.SWIG_IMPORTED_ARIA
class ArNetPacket(AriaPy.ArBasePacket):
    """Proxy of C++ ArNetPacket class."""

    __swig_setmethods__ = {}
    for _s in [AriaPy.ArBasePacket]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacket, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArBasePacket]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacket, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArNetPacket self, ArTypes::UByte2 bufferSize) -> ArNetPacket
        __init__(ArNetPacket self) -> ArNetPacket
        __init__(ArNetPacket self, ArNetPacket other) -> ArNetPacket
        """
        this = _ArNetworkingPy.new_ArNetPacket(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacket
    __del__ = lambda self: None

    def setCommand(self, command):
        """setCommand(ArNetPacket self, ArTypes::UByte2 command)"""
        return _ArNetworkingPy.ArNetPacket_setCommand(self, command)


    def getCommand(self):
        """getCommand(ArNetPacket self) -> ArTypes::UByte2"""
        return _ArNetworkingPy.ArNetPacket_getCommand(self)

    SIZE_OF_LENGTH = _ArNetworkingPy.ArNetPacket_SIZE_OF_LENGTH
    MAX_LENGTH = _ArNetworkingPy.ArNetPacket_MAX_LENGTH
    HEADER_LENGTH = _ArNetworkingPy.ArNetPacket_HEADER_LENGTH
    FOOTER_LENGTH = _ArNetworkingPy.ArNetPacket_FOOTER_LENGTH
    MAX_DATA_LENGTH = _ArNetworkingPy.ArNetPacket_MAX_DATA_LENGTH

    def doubleToBuf(self, val):
        """doubleToBuf(ArNetPacket self, double val)"""
        return _ArNetworkingPy.ArNetPacket_doubleToBuf(self, val)


    def bufToDouble(self):
        """bufToDouble(ArNetPacket self) -> double"""
        return _ArNetworkingPy.ArNetPacket_bufToDouble(self)


    def empty(self):
        """empty(ArNetPacket self)"""
        return _ArNetworkingPy.ArNetPacket_empty(self)


    def finalizePacket(self):
        """finalizePacket(ArNetPacket self)"""
        return _ArNetworkingPy.ArNetPacket_finalizePacket(self)


    def resetRead(self):
        """resetRead(ArNetPacket self)"""
        return _ArNetworkingPy.ArNetPacket_resetRead(self)


    def duplicatePacket(self, packet):
        """duplicatePacket(ArNetPacket self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArNetPacket_duplicatePacket(self, packet)


    def verifyCheckSum(self):
        """verifyCheckSum(ArNetPacket self) -> bool"""
        return _ArNetworkingPy.ArNetPacket_verifyCheckSum(self)


    def calcCheckSum(self):
        """calcCheckSum(ArNetPacket self) -> ArTypes::Byte2"""
        return _ArNetworkingPy.ArNetPacket_calcCheckSum(self)


    def getAddedFooter(self):
        """getAddedFooter(ArNetPacket self) -> bool"""
        return _ArNetworkingPy.ArNetPacket_getAddedFooter(self)


    def setAddedFooter(self, addedFooter):
        """setAddedFooter(ArNetPacket self, bool addedFooter)"""
        return _ArNetworkingPy.ArNetPacket_setAddedFooter(self, addedFooter)

    TCP = _ArNetworkingPy.ArNetPacket_TCP
    UDP = _ArNetworkingPy.ArNetPacket_UDP

    def getPacketSource(self):
        """getPacketSource(ArNetPacket self) -> ArNetPacket::PacketSource"""
        return _ArNetworkingPy.ArNetPacket_getPacketSource(self)


    def setPacketSource(self, source):
        """setPacketSource(ArNetPacket self, ArNetPacket::PacketSource source)"""
        return _ArNetworkingPy.ArNetPacket_setPacketSource(self, source)


    def setArbitraryString(self, string):
        """setArbitraryString(ArNetPacket self, char const * string)"""
        return _ArNetworkingPy.ArNetPacket_setArbitraryString(self, string)


    def getArbitraryString(self):
        """getArbitraryString(ArNetPacket self) -> char const *"""
        return _ArNetworkingPy.ArNetPacket_getArbitraryString(self)

ArNetPacket_swigregister = _ArNetworkingPy.ArNetPacket_swigregister
ArNetPacket_swigregister(ArNetPacket)

class ArServerBase(AriaPy.ArASyncTask):
    """Proxy of C++ ArServerBase class."""

    __swig_setmethods__ = {}
    for _s in [AriaPy.ArASyncTask]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerBase, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArASyncTask]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerBase, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName, bool addBackupTimeoutToConfig=True, char const * backupTimeoutName, char const * backupTimeoutDesc, bool masterServer=False, bool slaveServer=False, bool logPasswordFailureVerbosely=False, bool allowSlowPackets=True, bool allowIdlePackets=True, int maxClientsAllowed=-1, int warningTimeMSec=250) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName, bool addBackupTimeoutToConfig=True, char const * backupTimeoutName, char const * backupTimeoutDesc, bool masterServer=False, bool slaveServer=False, bool logPasswordFailureVerbosely=False, bool allowSlowPackets=True, bool allowIdlePackets=True, int maxClientsAllowed=-1) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName, bool addBackupTimeoutToConfig=True, char const * backupTimeoutName, char const * backupTimeoutDesc, bool masterServer=False, bool slaveServer=False, bool logPasswordFailureVerbosely=False, bool allowSlowPackets=True, bool allowIdlePackets=True) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName, bool addBackupTimeoutToConfig=True, char const * backupTimeoutName, char const * backupTimeoutDesc, bool masterServer=False, bool slaveServer=False, bool logPasswordFailureVerbosely=False, bool allowSlowPackets=True) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName, bool addBackupTimeoutToConfig=True, char const * backupTimeoutName, char const * backupTimeoutDesc, bool masterServer=False, bool slaveServer=False, bool logPasswordFailureVerbosely=False) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName, bool addBackupTimeoutToConfig=True, char const * backupTimeoutName, char const * backupTimeoutDesc, bool masterServer=False, bool slaveServer=False) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName, bool addBackupTimeoutToConfig=True, char const * backupTimeoutName, char const * backupTimeoutDesc, bool masterServer=False) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName, bool addBackupTimeoutToConfig=True, char const * backupTimeoutName, char const * backupTimeoutDesc) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName, bool addBackupTimeoutToConfig=True, char const * backupTimeoutName) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName, bool addBackupTimeoutToConfig=True) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True, char const * serverName) -> ArServerBase
        __init__(ArServerBase self, bool addAriaExitCB=True) -> ArServerBase
        __init__(ArServerBase self) -> ArServerBase
        """
        this = _ArNetworkingPy.new_ArServerBase(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerBase
    __del__ = lambda self: None

    def open(self, port, openOnIP=None, tcpOnly=False):
        """
        open(ArServerBase self, unsigned int port, char const * openOnIP=None, bool tcpOnly=False) -> bool
        open(ArServerBase self, unsigned int port, char const * openOnIP=None) -> bool
        open(ArServerBase self, unsigned int port) -> bool
        """
        return _ArNetworkingPy.ArServerBase_open(self, port, openOnIP, tcpOnly)


    def close(self):
        """close(ArServerBase self)"""
        return _ArNetworkingPy.ArServerBase_close(self)


    def loopOnce(self):
        """loopOnce(ArServerBase self)"""
        return _ArNetworkingPy.ArServerBase_loopOnce(self)


    def addData(self, name, description, functor, argumentDescription, returnDescription, commandGroup=None, dataFlags=None):
        """
        addData(ArServerBase self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription, char const * commandGroup=None, char const * dataFlags=None) -> bool
        addData(ArServerBase self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription, char const * commandGroup=None) -> bool
        addData(ArServerBase self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription) -> bool
        """
        return _ArNetworkingPy.ArServerBase_addData(self, name, description, functor, argumentDescription, returnDescription, commandGroup, dataFlags)


    def loadUserInfo(self, *args):
        """
        loadUserInfo(ArServerBase self, char const * fileName, char const * baseDirectory) -> bool
        loadUserInfo(ArServerBase self, char const * fileName) -> bool
        """
        return _ArNetworkingPy.ArServerBase_loadUserInfo(self, *args)


    def logUserInfo(self):
        """logUserInfo(ArServerBase self)"""
        return _ArNetworkingPy.ArServerBase_logUserInfo(self)


    def logCommandGroups(self):
        """logCommandGroups(ArServerBase self)"""
        return _ArNetworkingPy.ArServerBase_logCommandGroups(self)


    def logCommandGroupsToFile(self, fileName):
        """logCommandGroupsToFile(ArServerBase self, char const * fileName)"""
        return _ArNetworkingPy.ArServerBase_logCommandGroupsToFile(self, fileName)


    def setGroupDescription(self, GrpName, GrpDesc):
        """setGroupDescription(ArServerBase self, char const * GrpName, char const * GrpDesc)"""
        return _ArNetworkingPy.ArServerBase_setGroupDescription(self, GrpName, GrpDesc)


    def logGroupDescriptions(self):
        """logGroupDescriptions(ArServerBase self)"""
        return _ArNetworkingPy.ArServerBase_logGroupDescriptions(self)


    def logGroupDescriptionsToFile(self, fileName):
        """logGroupDescriptionsToFile(ArServerBase self, char const * fileName)"""
        return _ArNetworkingPy.ArServerBase_logGroupDescriptionsToFile(self, fileName)


    def setServerKey(self, serverKey):
        """setServerKey(ArServerBase self, char const * serverKey)"""
        return _ArNetworkingPy.ArServerBase_setServerKey(self, serverKey)


    def rejectSinceUsingCentralServer(self, centralServerIPString):
        """rejectSinceUsingCentralServer(ArServerBase self, char const * centralServerIPString)"""
        return _ArNetworkingPy.ArServerBase_rejectSinceUsingCentralServer(self, centralServerIPString)


    def enforceProtocolVersion(self, protocolVersion):
        """enforceProtocolVersion(ArServerBase self, char const * protocolVersion)"""
        return _ArNetworkingPy.ArServerBase_enforceProtocolVersion(self, protocolVersion)


    def enforceType(self, type):
        """enforceType(ArServerBase self, ArServerCommands::Type type)"""
        return _ArNetworkingPy.ArServerBase_enforceType(self, type)


    def setBackupTimeout(self, timeoutInMins):
        """setBackupTimeout(ArServerBase self, double timeoutInMins)"""
        return _ArNetworkingPy.ArServerBase_setBackupTimeout(self, timeoutInMins)


    def run(self):
        """run(ArServerBase self)"""
        return _ArNetworkingPy.ArServerBase_run(self)


    def runAsync(self):
        """runAsync(ArServerBase self)"""
        return _ArNetworkingPy.ArServerBase_runAsync(self)


    def logConnections(self, *args):
        """
        logConnections(ArServerBase self, char const * prefix)
        logConnections(ArServerBase self)
        """
        return _ArNetworkingPy.ArServerBase_logConnections(self, *args)


    def getNumClients(self):
        """getNumClients(ArServerBase self) -> int"""
        return _ArNetworkingPy.ArServerBase_getNumClients(self)


    def findCommandFromName(self, command):
        """findCommandFromName(ArServerBase self, char const * command) -> unsigned int"""
        return _ArNetworkingPy.ArServerBase_findCommandFromName(self, command)


    def broadcastPacketTcp(self, packet, name):
        """broadcastPacketTcp(ArServerBase self, ArNetPacket packet, char const * name) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcp(self, packet, name)


    def broadcastPacketTcpToMatching(self, packet, name, identifier, matchConnectionID=False):
        """
        broadcastPacketTcpToMatching(ArServerBase self, ArNetPacket packet, char const * name, ArServerClientIdentifier identifier, bool matchConnectionID=False) -> bool
        broadcastPacketTcpToMatching(ArServerBase self, ArNetPacket packet, char const * name, ArServerClientIdentifier identifier) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpToMatching(self, packet, name, identifier, matchConnectionID)


    def broadcastPacketTcpWithExclusion(self, *args):
        """
        broadcastPacketTcpWithExclusion(ArServerBase self, ArNetPacket packet, char const * name, ArServerClient excludeClient, bool match=False, ArServerClientIdentifier identifier, bool matchConnectionID=False) -> bool
        broadcastPacketTcpWithExclusion(ArServerBase self, ArNetPacket packet, char const * name, ArServerClient excludeClient, bool match=False, ArServerClientIdentifier identifier) -> bool
        broadcastPacketTcpWithExclusion(ArServerBase self, ArNetPacket packet, char const * name, ArServerClient excludeClient, bool match=False) -> bool
        broadcastPacketTcpWithExclusion(ArServerBase self, ArNetPacket packet, char const * name, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpWithExclusion(self, *args)


    def broadcastPacketUdp(self, packet, name):
        """broadcastPacketUdp(ArServerBase self, ArNetPacket packet, char const * name) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdp(self, packet, name)


    def broadcastPacketUdpWithExclusion(self, *args):
        """
        broadcastPacketUdpWithExclusion(ArServerBase self, ArNetPacket packet, char const * name, ArServerClient excludeClient, bool match=False, ArServerClientIdentifier identifier, bool matchConnectionID=False) -> bool
        broadcastPacketUdpWithExclusion(ArServerBase self, ArNetPacket packet, char const * name, ArServerClient excludeClient, bool match=False, ArServerClientIdentifier identifier) -> bool
        broadcastPacketUdpWithExclusion(ArServerBase self, ArNetPacket packet, char const * name, ArServerClient excludeClient, bool match=False) -> bool
        broadcastPacketUdpWithExclusion(ArServerBase self, ArNetPacket packet, char const * name, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpWithExclusion(self, *args)


    def broadcastPacketUdpToMatching(self, packet, name, identifier, matchConnectionID):
        """broadcastPacketUdpToMatching(ArServerBase self, ArNetPacket packet, char const * name, ArServerClientIdentifier identifier, bool matchConnectionID) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpToMatching(self, packet, name, identifier, matchConnectionID)


    def sleepAfterSend(self, msecDelay):
        """sleepAfterSend(ArServerBase self, int msecDelay)"""
        return _ArNetworkingPy.ArServerBase_sleepAfterSend(self, msecDelay)


    def idleProcessingPending(self):
        """idleProcessingPending(ArServerBase self) -> bool"""
        return _ArNetworkingPy.ArServerBase_idleProcessingPending(self)


    def processPacket(self, packet, sin):
        """processPacket(ArServerBase self, ArNetPacket packet, sockaddr_in * sin)"""
        return _ArNetworkingPy.ArServerBase_processPacket(self, packet, sin)


    def sendUdp(self, packet, sin):
        """sendUdp(ArServerBase self, ArNetPacket packet, sockaddr_in * sin) -> bool"""
        return _ArNetworkingPy.ArServerBase_sendUdp(self, packet, sin)


    def logTracking(self, terse=True):
        """
        logTracking(ArServerBase self, bool terse=True)
        logTracking(ArServerBase self)
        """
        return _ArNetworkingPy.ArServerBase_logTracking(self, terse)


    def resetTracking(self):
        """resetTracking(ArServerBase self)"""
        return _ArNetworkingPy.ArServerBase_resetTracking(self)


    def runThread(self, arg):
        """runThread(ArServerBase self, void * arg) -> void *"""
        return _ArNetworkingPy.ArServerBase_runThread(self, arg)


    def getTcpPort(self):
        """getTcpPort(ArServerBase self) -> unsigned int"""
        return _ArNetworkingPy.ArServerBase_getTcpPort(self)


    def getUdpPort(self):
        """getUdpPort(ArServerBase self) -> unsigned int"""
        return _ArNetworkingPy.ArServerBase_getUdpPort(self)


    def getOpenOnIP(self):
        """getOpenOnIP(ArServerBase self) -> char const *"""
        return _ArNetworkingPy.ArServerBase_getOpenOnIP(self)


    def addCycleCallback(self, functor):
        """addCycleCallback(ArServerBase self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerBase_addCycleCallback(self, functor)


    def remCycleCallback(self, functor):
        """remCycleCallback(ArServerBase self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerBase_remCycleCallback(self, functor)


    def addClientRemovedCallback(self, functor):
        """addClientRemovedCallback(ArServerBase self, ArFunctor1< ArServerClient * > * functor)"""
        return _ArNetworkingPy.ArServerBase_addClientRemovedCallback(self, functor)


    def remClientRemovedCallback(self, functor):
        """remClientRemovedCallback(ArServerBase self, ArFunctor1< ArServerClient * > * functor)"""
        return _ArNetworkingPy.ArServerBase_remClientRemovedCallback(self, functor)


    def makeNewServerClientFromSocket(self, socket, overrideGeneralReject):
        """makeNewServerClientFromSocket(ArServerBase self, ArSocket socket, bool overrideGeneralReject) -> ArServerClient"""
        return _ArNetworkingPy.ArServerBase_makeNewServerClientFromSocket(self, socket, overrideGeneralReject)


    def getUserInfo(self):
        """getUserInfo(ArServerBase self) -> ArServerUserInfo"""
        return _ArNetworkingPy.ArServerBase_getUserInfo(self)


    def setUserInfo(self, userInfo):
        """setUserInfo(ArServerBase self, ArServerUserInfo userInfo)"""
        return _ArNetworkingPy.ArServerBase_setUserInfo(self, userInfo)


    def addDataAdvanced(self, name, description, functor, argumentDescription, returnDescription, commandGroup=None, dataFlags=None, commandNumber=0, requestChangedFunctor=None, requestOnceFunctor=None):
        """
        addDataAdvanced(ArServerBase self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription, char const * commandGroup=None, char const * dataFlags=None, unsigned int commandNumber=0, ArFunctor2< long,unsigned int > * requestChangedFunctor=None, ArRetFunctor2< bool,ArServerClient *,ArNetPacket * > * requestOnceFunctor=None) -> bool
        addDataAdvanced(ArServerBase self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription, char const * commandGroup=None, char const * dataFlags=None, unsigned int commandNumber=0, ArFunctor2< long,unsigned int > * requestChangedFunctor=None) -> bool
        addDataAdvanced(ArServerBase self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription, char const * commandGroup=None, char const * dataFlags=None, unsigned int commandNumber=0) -> bool
        addDataAdvanced(ArServerBase self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription, char const * commandGroup=None, char const * dataFlags=None) -> bool
        addDataAdvanced(ArServerBase self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription, char const * commandGroup=None) -> bool
        addDataAdvanced(ArServerBase self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription) -> bool
        """
        return _ArNetworkingPy.ArServerBase_addDataAdvanced(self, name, description, functor, argumentDescription, returnDescription, commandGroup, dataFlags, commandNumber, requestChangedFunctor, requestOnceFunctor)


    def setAdditionalDataFlags(self, additionalDataFlags):
        """setAdditionalDataFlags(ArServerBase self, char const * additionalDataFlags)"""
        return _ArNetworkingPy.ArServerBase_setAdditionalDataFlags(self, additionalDataFlags)


    def getFrequency(self, command, internalCall=False):
        """
        getFrequency(ArServerBase self, unsigned int command, bool internalCall=False) -> long
        getFrequency(ArServerBase self, unsigned int command) -> long
        """
        return _ArNetworkingPy.ArServerBase_getFrequency(self, command, internalCall)


    def broadcastPacketTcpByCommand(self, packet, command):
        """broadcastPacketTcpByCommand(ArServerBase self, ArNetPacket packet, unsigned int command) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpByCommand(self, packet, command)


    def broadcastPacketTcpByCommandWithExclusion(self, *args):
        """
        broadcastPacketTcpByCommandWithExclusion(ArServerBase self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, bool match=False, ArServerClientIdentifier identifier, bool matchConnectionID=False) -> bool
        broadcastPacketTcpByCommandWithExclusion(ArServerBase self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, bool match=False, ArServerClientIdentifier identifier) -> bool
        broadcastPacketTcpByCommandWithExclusion(ArServerBase self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, bool match=False) -> bool
        broadcastPacketTcpByCommandWithExclusion(ArServerBase self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpByCommandWithExclusion(self, *args)


    def broadcastPacketUdpByCommand(self, packet, command):
        """broadcastPacketUdpByCommand(ArServerBase self, ArNetPacket packet, unsigned int command) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpByCommand(self, packet, command)


    def broadcastPacketUdpByCommandWithExclusion(self, *args):
        """
        broadcastPacketUdpByCommandWithExclusion(ArServerBase self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, bool match=False, ArServerClientIdentifier identifier, bool matchConnectionID=False) -> bool
        broadcastPacketUdpByCommandWithExclusion(ArServerBase self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, bool match=False, ArServerClientIdentifier identifier) -> bool
        broadcastPacketUdpByCommandWithExclusion(ArServerBase self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, bool match=False) -> bool
        broadcastPacketUdpByCommandWithExclusion(ArServerBase self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpByCommandWithExclusion(self, *args)


    def closeConnectionID(self, idNum):
        """closeConnectionID(ArServerBase self, ArTypes::UByte4 idNum)"""
        return _ArNetworkingPy.ArServerBase_closeConnectionID(self, idNum)


    def dataHasFlag(self, name, dataFlag):
        """dataHasFlag(ArServerBase self, char const * name, char const * dataFlag) -> bool"""
        return _ArNetworkingPy.ArServerBase_dataHasFlag(self, name, dataFlag)


    def dataHasFlagByCommand(self, command, dataFlag):
        """dataHasFlagByCommand(ArServerBase self, unsigned int command, char const * dataFlag) -> bool"""
        return _ArNetworkingPy.ArServerBase_dataHasFlagByCommand(self, command, dataFlag)


    def setDebugLogging(self, debugLogging=False):
        """
        setDebugLogging(ArServerBase self, bool debugLogging=False)
        setDebugLogging(ArServerBase self)
        """
        return _ArNetworkingPy.ArServerBase_setDebugLogging(self, debugLogging)


    def getDebugLogging(self):
        """getDebugLogging(ArServerBase self) -> bool"""
        return _ArNetworkingPy.ArServerBase_getDebugLogging(self)


    def getMostClients(self):
        """getMostClients(ArServerBase self) -> int"""
        return _ArNetworkingPy.ArServerBase_getMostClients(self)


    def allowingIdlePackets(self):
        """allowingIdlePackets(ArServerBase self) -> bool"""
        return _ArNetworkingPy.ArServerBase_allowingIdlePackets(self)


    def addIdleSingleShotCallback(self, functor):
        """addIdleSingleShotCallback(ArServerBase self, ArFunctor functor) -> bool"""
        return _ArNetworkingPy.ArServerBase_addIdleSingleShotCallback(self, functor)


    def hasSlowPackets(self):
        """hasSlowPackets(ArServerBase self) -> bool"""
        return _ArNetworkingPy.ArServerBase_hasSlowPackets(self)


    def hasIdlePackets(self):
        """hasIdlePackets(ArServerBase self) -> bool"""
        return _ArNetworkingPy.ArServerBase_hasIdlePackets(self)


    def hasIdleCallbacks(self):
        """hasIdleCallbacks(ArServerBase self) -> bool"""
        return _ArNetworkingPy.ArServerBase_hasIdleCallbacks(self)


    def internalSetNumClients(self, numClients):
        """internalSetNumClients(ArServerBase self, int numClients)"""
        return _ArNetworkingPy.ArServerBase_internalSetNumClients(self, numClients)


    def addTooManyClientsCB(self, functor, position=50):
        """
        addTooManyClientsCB(ArServerBase self, ArFunctor1_CString functor, int position=50)
        addTooManyClientsCB(ArServerBase self, ArFunctor1_CString functor)
        """
        return _ArNetworkingPy.ArServerBase_addTooManyClientsCB(self, functor, position)


    def remTooManyClientsCB(self, functor):
        """remTooManyClientsCB(ArServerBase self, ArFunctor1_CString functor)"""
        return _ArNetworkingPy.ArServerBase_remTooManyClientsCB(self, functor)


    def internalSetDefaultFrequency(self, command, frequency):
        """internalSetDefaultFrequency(ArServerBase self, char const * command, int frequency) -> bool"""
        return _ArNetworkingPy.ArServerBase_internalSetDefaultFrequency(self, command, frequency)


    def internalLockup(self):
        """internalLockup(ArServerBase self)"""
        return _ArNetworkingPy.ArServerBase_internalLockup(self)


    def remData(self, name):
        """remData(ArServerBase self, char const * name)"""
        return _ArNetworkingPy.ArServerBase_remData(self, name)

ArServerBase_swigregister = _ArNetworkingPy.ArServerBase_swigregister
ArServerBase_swigregister(ArServerBase)

class ArServerMode(_object):
    """Proxy of C++ ArServerMode class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerMode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerMode, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerMode
    __del__ = lambda self: None

    def getActionGroup(self):
        """getActionGroup(ArServerMode self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerMode_getActionGroup(self)


    def activate(self):
        """activate(ArServerMode self)"""
        return _ArNetworkingPy.ArServerMode_activate(self)


    def deactivate(self):
        """deactivate(ArServerMode self)"""
        return _ArNetworkingPy.ArServerMode_deactivate(self)


    def activationDenied(self):
        """activationDenied(ArServerMode self)"""
        return _ArNetworkingPy.ArServerMode_activationDenied(self)


    def userTask(self):
        """userTask(ArServerMode self)"""
        return _ArNetworkingPy.ArServerMode_userTask(self)


    def requestUnlock(self):
        """requestUnlock(ArServerMode self)"""
        return _ArNetworkingPy.ArServerMode_requestUnlock(self)


    def forceUnlock(self):
        """forceUnlock(ArServerMode self)"""
        return _ArNetworkingPy.ArServerMode_forceUnlock(self)


    def lockMode(self, willUnlockIfRequested=False):
        """
        lockMode(ArServerMode self, bool willUnlockIfRequested=False)
        lockMode(ArServerMode self)
        """
        return _ArNetworkingPy.ArServerMode_lockMode(self, willUnlockIfRequested)


    def unlockMode(self):
        """unlockMode(ArServerMode self)"""
        return _ArNetworkingPy.ArServerMode_unlockMode(self)


    def getMode(self):
        """getMode(ArServerMode self) -> char const *"""
        return _ArNetworkingPy.ArServerMode_getMode(self)


    def getStatus(self):
        """getStatus(ArServerMode self) -> char const *"""
        return _ArNetworkingPy.ArServerMode_getStatus(self)


    def getExtendedStatus(self):
        """getExtendedStatus(ArServerMode self) -> char const *"""
        return _ArNetworkingPy.ArServerMode_getExtendedStatus(self)


    def getActiveModeModeString():
        """getActiveModeModeString() -> char const *"""
        return _ArNetworkingPy.ArServerMode_getActiveModeModeString()

    if _newclass:
        getActiveModeModeString = staticmethod(getActiveModeModeString)
    __swig_getmethods__["getActiveModeModeString"] = lambda x: getActiveModeModeString

    def getActiveModeStatusString():
        """getActiveModeStatusString() -> char const *"""
        return _ArNetworkingPy.ArServerMode_getActiveModeStatusString()

    if _newclass:
        getActiveModeStatusString = staticmethod(getActiveModeStatusString)
    __swig_getmethods__["getActiveModeStatusString"] = lambda x: getActiveModeStatusString

    def getActiveModeExtendedStatusString():
        """getActiveModeExtendedStatusString() -> char const *"""
        return _ArNetworkingPy.ArServerMode_getActiveModeExtendedStatusString()

    if _newclass:
        getActiveModeExtendedStatusString = staticmethod(getActiveModeExtendedStatusString)
    __swig_getmethods__["getActiveModeExtendedStatusString"] = lambda x: getActiveModeExtendedStatusString

    def getName(self):
        """getName(ArServerMode self) -> char const *"""
        return _ArNetworkingPy.ArServerMode_getName(self)


    def isActive(self):
        """isActive(ArServerMode self) -> bool"""
        return _ArNetworkingPy.ArServerMode_isActive(self)


    def isLocked():
        """isLocked() -> bool"""
        return _ArNetworkingPy.ArServerMode_isLocked()

    if _newclass:
        isLocked = staticmethod(isLocked)
    __swig_getmethods__["isLocked"] = lambda x: isLocked

    def willUnlockIfRequested():
        """willUnlockIfRequested() -> bool"""
        return _ArNetworkingPy.ArServerMode_willUnlockIfRequested()

    if _newclass:
        willUnlockIfRequested = staticmethod(willUnlockIfRequested)
    __swig_getmethods__["willUnlockIfRequested"] = lambda x: willUnlockIfRequested

    def getActiveMode():
        """getActiveMode() -> ArServerMode"""
        return _ArNetworkingPy.ArServerMode_getActiveMode()

    if _newclass:
        getActiveMode = staticmethod(getActiveMode)
    __swig_getmethods__["getActiveMode"] = lambda x: getActiveMode

    def hasSetActivityTime(self):
        """hasSetActivityTime(ArServerMode self) -> bool"""
        return _ArNetworkingPy.ArServerMode_hasSetActivityTime(self)


    def getActivityTime(self):
        """getActivityTime(ArServerMode self) -> ArTime"""
        return _ArNetworkingPy.ArServerMode_getActivityTime(self)


    def setActivityTimeToNow(self):
        """setActivityTimeToNow(ArServerMode self)"""
        return _ArNetworkingPy.ArServerMode_setActivityTimeToNow(self)


    def getActiveModeActivityTimeSecSince():
        """getActiveModeActivityTimeSecSince() -> int"""
        return _ArNetworkingPy.ArServerMode_getActiveModeActivityTimeSecSince()

    if _newclass:
        getActiveModeActivityTimeSecSince = staticmethod(getActiveModeActivityTimeSecSince)
    __swig_getmethods__["getActiveModeActivityTimeSecSince"] = lambda x: getActiveModeActivityTimeSecSince

    def getActiveModeSetActivityThisCycle():
        """getActiveModeSetActivityThisCycle() -> bool"""
        return _ArNetworkingPy.ArServerMode_getActiveModeSetActivityThisCycle()

    if _newclass:
        getActiveModeSetActivityThisCycle = staticmethod(getActiveModeSetActivityThisCycle)
    __swig_getmethods__["getActiveModeSetActivityThisCycle"] = lambda x: getActiveModeSetActivityThisCycle

    def addAsDefaultMode(self, *args):
        """
        addAsDefaultMode(ArServerMode self, ArListPos::Pos pos)
        addAsDefaultMode(ArServerMode self)
        """
        return _ArNetworkingPy.ArServerMode_addAsDefaultMode(self, *args)


    def checkDefault(self):
        """checkDefault(ArServerMode self)"""
        return _ArNetworkingPy.ArServerMode_checkDefault(self)


    def setMode(self, str):
        """setMode(ArServerMode self, char const * str)"""
        return _ArNetworkingPy.ArServerMode_setMode(self, str)


    def setStatus(self, str):
        """setStatus(ArServerMode self, char const * str)"""
        return _ArNetworkingPy.ArServerMode_setStatus(self, str)


    def isAutoResumeAfterInterrupt(self):
        """isAutoResumeAfterInterrupt(ArServerMode self) -> bool"""
        return _ArNetworkingPy.ArServerMode_isAutoResumeAfterInterrupt(self)


    def addModeData(self, name, description, functor, argumentDescription, returnDescription, commandGroup=None, dataFlags=None):
        """
        addModeData(ArServerMode self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription, char const * commandGroup=None, char const * dataFlags=None) -> bool
        addModeData(ArServerMode self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription, char const * commandGroup=None) -> bool
        addModeData(ArServerMode self, char const * name, char const * description, ArFunctor2< ArServerClient *,ArNetPacket * > * functor, char const * argumentDescription, char const * returnDescription) -> bool
        """
        return _ArNetworkingPy.ArServerMode_addModeData(self, name, description, functor, argumentDescription, returnDescription, commandGroup, dataFlags)


    def getModeDataList(client, packet):
        """getModeDataList(ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerMode_getModeDataList(client, packet)

    if _newclass:
        getModeDataList = staticmethod(getModeDataList)
    __swig_getmethods__["getModeDataList"] = lambda x: getModeDataList

    def getModeInfo(client, packet):
        """getModeInfo(ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerMode_getModeInfo(client, packet)

    if _newclass:
        getModeInfo = staticmethod(getModeInfo)
    __swig_getmethods__["getModeInfo"] = lambda x: getModeInfo

    def getModeBusy(client, packet):
        """getModeBusy(ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerMode_getModeBusy(client, packet)

    if _newclass:
        getModeBusy = staticmethod(getModeBusy)
    __swig_getmethods__["getModeBusy"] = lambda x: getModeBusy

    def addActivateCallback(self, functor, position=50):
        """
        addActivateCallback(ArServerMode self, ArFunctor functor, int position=50)
        addActivateCallback(ArServerMode self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addActivateCallback(self, functor, position)


    def remActivateCallback(self, functor):
        """remActivateCallback(ArServerMode self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remActivateCallback(self, functor)


    def addDeactivateCallback(self, functor, position=50):
        """
        addDeactivateCallback(ArServerMode self, ArFunctor functor, int position=50)
        addDeactivateCallback(ArServerMode self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addDeactivateCallback(self, functor, position)


    def remDeactivateCallback(self, functor):
        """remDeactivateCallback(ArServerMode self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remDeactivateCallback(self, functor)


    def addSingleShotDeactivateCallback(self, functor, position=50):
        """
        addSingleShotDeactivateCallback(ArServerMode self, ArFunctor functor, int position=50)
        addSingleShotDeactivateCallback(ArServerMode self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addSingleShotDeactivateCallback(self, functor, position)


    def remSingleShotDeactivateCallback(self, functor):
        """remSingleShotDeactivateCallback(ArServerMode self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remSingleShotDeactivateCallback(self, functor)


    def addSingleShotPostDeactivateCallback(self, functor, position=50):
        """
        addSingleShotPostDeactivateCallback(ArServerMode self, ArFunctor functor, int position=50)
        addSingleShotPostDeactivateCallback(ArServerMode self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addSingleShotPostDeactivateCallback(self, functor, position)


    def remSingleShotPostDeactivateCallback(self, functor):
        """remSingleShotPostDeactivateCallback(ArServerMode self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remSingleShotPostDeactivateCallback(self, functor)


    def getIdleMode():
        """getIdleMode() -> ArServerModeIdle"""
        return _ArNetworkingPy.ArServerMode_getIdleMode()

    if _newclass:
        getIdleMode = staticmethod(getIdleMode)
    __swig_getmethods__["getIdleMode"] = lambda x: getIdleMode
ArServerMode_swigregister = _ArNetworkingPy.ArServerMode_swigregister
ArServerMode_swigregister(ArServerMode)

def ArServerMode_getActiveModeModeString():
    """ArServerMode_getActiveModeModeString() -> char const *"""
    return _ArNetworkingPy.ArServerMode_getActiveModeModeString()

def ArServerMode_getActiveModeStatusString():
    """ArServerMode_getActiveModeStatusString() -> char const *"""
    return _ArNetworkingPy.ArServerMode_getActiveModeStatusString()

def ArServerMode_getActiveModeExtendedStatusString():
    """ArServerMode_getActiveModeExtendedStatusString() -> char const *"""
    return _ArNetworkingPy.ArServerMode_getActiveModeExtendedStatusString()

def ArServerMode_isLocked():
    """ArServerMode_isLocked() -> bool"""
    return _ArNetworkingPy.ArServerMode_isLocked()

def ArServerMode_willUnlockIfRequested():
    """ArServerMode_willUnlockIfRequested() -> bool"""
    return _ArNetworkingPy.ArServerMode_willUnlockIfRequested()

def ArServerMode_getActiveMode():
    """ArServerMode_getActiveMode() -> ArServerMode"""
    return _ArNetworkingPy.ArServerMode_getActiveMode()

def ArServerMode_getActiveModeActivityTimeSecSince():
    """ArServerMode_getActiveModeActivityTimeSecSince() -> int"""
    return _ArNetworkingPy.ArServerMode_getActiveModeActivityTimeSecSince()

def ArServerMode_getActiveModeSetActivityThisCycle():
    """ArServerMode_getActiveModeSetActivityThisCycle() -> bool"""
    return _ArNetworkingPy.ArServerMode_getActiveModeSetActivityThisCycle()

def ArServerMode_getModeDataList(client, packet):
    """ArServerMode_getModeDataList(ArServerClient client, ArNetPacket packet)"""
    return _ArNetworkingPy.ArServerMode_getModeDataList(client, packet)

def ArServerMode_getModeInfo(client, packet):
    """ArServerMode_getModeInfo(ArServerClient client, ArNetPacket packet)"""
    return _ArNetworkingPy.ArServerMode_getModeInfo(client, packet)

def ArServerMode_getModeBusy(client, packet):
    """ArServerMode_getModeBusy(ArServerClient client, ArNetPacket packet)"""
    return _ArNetworkingPy.ArServerMode_getModeBusy(client, packet)

def ArServerMode_getIdleMode():
    """ArServerMode_getIdleMode() -> ArServerModeIdle"""
    return _ArNetworkingPy.ArServerMode_getIdleMode()

class ArClientArg(_object):
    """Proxy of C++ ArClientArg class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientArg, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientArg, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArClientArg self, bool isDisplayHintParsed=False, ArPriority::Priority lastPriority, int version=1, bool isSingleParam=False) -> ArClientArg
        __init__(ArClientArg self, bool isDisplayHintParsed=False, ArPriority::Priority lastPriority, int version=1) -> ArClientArg
        __init__(ArClientArg self, bool isDisplayHintParsed=False, ArPriority::Priority lastPriority) -> ArClientArg
        __init__(ArClientArg self, bool isDisplayHintParsed=False) -> ArClientArg
        __init__(ArClientArg self) -> ArClientArg
        """
        this = _ArNetworkingPy.new_ArClientArg(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientArg
    __del__ = lambda self: None

    def isSendableParamType(arg, isIncludeSeparator=True):
        """
        isSendableParamType(ArConfigArg arg, bool isIncludeSeparator=True) -> bool
        isSendableParamType(ArConfigArg arg) -> bool
        """
        return _ArNetworkingPy.ArClientArg_isSendableParamType(arg, isIncludeSeparator)

    if _newclass:
        isSendableParamType = staticmethod(isSendableParamType)
    __swig_getmethods__["isSendableParamType"] = lambda x: isSendableParamType

    def createArg(self, packet, argOut, parentPathNameOut=None):
        """
        createArg(ArClientArg self, ArNetPacket packet, ArConfigArg argOut, std::string * parentPathNameOut=None) -> bool
        createArg(ArClientArg self, ArNetPacket packet, ArConfigArg argOut) -> bool
        """
        return _ArNetworkingPy.ArClientArg_createArg(self, packet, argOut, parentPathNameOut)


    def createPacket(self, arg, packet, parentPathName=None):
        """
        createPacket(ArClientArg self, ArConfigArg arg, ArNetPacket packet, char const * parentPathName=None) -> bool
        createPacket(ArClientArg self, ArConfigArg arg, ArNetPacket packet) -> bool
        """
        return _ArNetworkingPy.ArClientArg_createPacket(self, arg, packet, parentPathName)


    def bufToArgValue(self, packet, arg):
        """bufToArgValue(ArClientArg self, ArNetPacket packet, ArConfigArg arg) -> bool"""
        return _ArNetworkingPy.ArClientArg_bufToArgValue(self, packet, arg)


    def argValueToBuf(self, arg, packet):
        """argValueToBuf(ArClientArg self, ArConfigArg arg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_argValueToBuf(self, arg, packet)


    def argTextToBuf(self, arg, packet):
        """argTextToBuf(ArClientArg self, ArConfigArg arg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_argTextToBuf(self, arg, packet)


    def addArgTextToPacket(self, arg, packet):
        """addArgTextToPacket(ArClientArg self, ArConfigArg arg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_addArgTextToPacket(self, arg, packet)


    def addAncestorListToPacket(self, ancestorList, packet):
        """addAncestorListToPacket(ArClientArg self, std::list< ArConfigArg *,std::allocator< ArConfigArg * > > const & ancestorList, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_addAncestorListToPacket(self, ancestorList, packet)


    def addListBeginToPacket(self, parentArg, packet):
        """addListBeginToPacket(ArClientArg self, ArConfigArg parentArg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_addListBeginToPacket(self, parentArg, packet)


    def addListEndToPacket(self, parentArg, packet):
        """addListEndToPacket(ArClientArg self, ArConfigArg parentArg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_addListEndToPacket(self, parentArg, packet)

ArClientArg_swigregister = _ArNetworkingPy.ArClientArg_swigregister
ArClientArg_swigregister(ArClientArg)

def ArClientArg_isSendableParamType(arg, isIncludeSeparator=True):
    """
    isSendableParamType(ArConfigArg arg, bool isIncludeSeparator=True) -> bool
    ArClientArg_isSendableParamType(ArConfigArg arg) -> bool
    """
    return _ArNetworkingPy.ArClientArg_isSendableParamType(arg, isIncludeSeparator)

class ArClientBase(AriaPy.ArASyncTask):
    """Proxy of C++ ArClientBase class."""

    __swig_setmethods__ = {}
    for _s in [AriaPy.ArASyncTask]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientBase, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArASyncTask]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientBase, name)
    __repr__ = _swig_repr
    STATE_NO_CONNECTION = _ArNetworkingPy.ArClientBase_STATE_NO_CONNECTION
    STATE_FAILED_CONNECTION = _ArNetworkingPy.ArClientBase_STATE_FAILED_CONNECTION
    STATE_OPENED_SOCKET = _ArNetworkingPy.ArClientBase_STATE_OPENED_SOCKET
    STATE_EXCHANGED_INTROS = _ArNetworkingPy.ArClientBase_STATE_EXCHANGED_INTROS
    STATE_REJECTED = _ArNetworkingPy.ArClientBase_STATE_REJECTED
    STATE_WAITING_LIST = _ArNetworkingPy.ArClientBase_STATE_WAITING_LIST
    STATE_CONNECTED = _ArNetworkingPy.ArClientBase_STATE_CONNECTED
    STATE_LOST_CONNECTION = _ArNetworkingPy.ArClientBase_STATE_LOST_CONNECTION
    CLIENT_KEY_LENGTH = _ArNetworkingPy.ArClientBase_CLIENT_KEY_LENGTH
    NON_BLOCKING_CONTINUE = _ArNetworkingPy.ArClientBase_NON_BLOCKING_CONTINUE
    NON_BLOCKING_CONNECTED = _ArNetworkingPy.ArClientBase_NON_BLOCKING_CONNECTED
    NON_BLOCKING_FAILED = _ArNetworkingPy.ArClientBase_NON_BLOCKING_FAILED

    def __init__(self):
        """__init__(ArClientBase self) -> ArClientBase"""
        this = _ArNetworkingPy.new_ArClientBase()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientBase
    __del__ = lambda self: None

    def setRobotName(self, name, debugLogging=False, robotId=0):
        """
        setRobotName(ArClientBase self, char const * name, bool debugLogging=False, int robotId=0)
        setRobotName(ArClientBase self, char const * name, bool debugLogging=False)
        setRobotName(ArClientBase self, char const * name)
        """
        return _ArNetworkingPy.ArClientBase_setRobotName(self, name, debugLogging, robotId)


    def getRobotName(self):
        """getRobotName(ArClientBase self) -> char const *"""
        return _ArNetworkingPy.ArClientBase_getRobotName(self)


    def getLogPrefix(self):
        """getLogPrefix(ArClientBase self) -> char const *"""
        return _ArNetworkingPy.ArClientBase_getLogPrefix(self)


    def getDebugLogging(self):
        """getDebugLogging(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getDebugLogging(self)


    def blockingConnect(self, host, port, log=True, user=None, password=None, openOnIP=None):
        """
        blockingConnect(ArClientBase self, char const * host, int port, bool log=True, char const * user=None, char const * password=None, char const * openOnIP=None) -> bool
        blockingConnect(ArClientBase self, char const * host, int port, bool log=True, char const * user=None, char const * password=None) -> bool
        blockingConnect(ArClientBase self, char const * host, int port, bool log=True, char const * user=None) -> bool
        blockingConnect(ArClientBase self, char const * host, int port, bool log=True) -> bool
        blockingConnect(ArClientBase self, char const * host, int port) -> bool
        """
        return _ArNetworkingPy.ArClientBase_blockingConnect(self, host, port, log, user, password, openOnIP)


    def disconnect(self):
        """disconnect(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_disconnect(self)


    def disconnectSoon(self):
        """disconnectSoon(ArClientBase self)"""
        return _ArNetworkingPy.ArClientBase_disconnectSoon(self)


    def isConnected(self):
        """isConnected(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isConnected(self)


    def wasRejected(self):
        """wasRejected(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_wasRejected(self)


    def getState(self):
        """getState(ArClientBase self) -> ArClientBase::ClientState"""
        return _ArNetworkingPy.ArClientBase_getState(self)


    def addHandler(self, name, functor, takeOwnershipOfFunctor=False):
        """
        addHandler(ArClientBase self, char const * name, ArFunctor1< ArNetPacket * > * functor, bool takeOwnershipOfFunctor=False) -> bool
        addHandler(ArClientBase self, char const * name, ArFunctor1< ArNetPacket * > * functor) -> bool
        """
        return _ArNetworkingPy.ArClientBase_addHandler(self, name, functor, takeOwnershipOfFunctor)


    def remHandler(self, name, functor):
        """remHandler(ArClientBase self, char const * name, ArFunctor1< ArNetPacket * > * functor) -> bool"""
        return _ArNetworkingPy.ArClientBase_remHandler(self, name, functor)


    def request(self, name, mSec, packet=None):
        """
        request(ArClientBase self, char const * name, long mSec, ArNetPacket packet=None) -> bool
        request(ArClientBase self, char const * name, long mSec) -> bool
        """
        return _ArNetworkingPy.ArClientBase_request(self, name, mSec, packet)


    def requestStop(self, name):
        """requestStop(ArClientBase self, char const * name) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestStop(self, name)


    def requestOnce(self, name, packet=None, quiet=False):
        """
        requestOnce(ArClientBase self, char const * name, ArNetPacket packet=None, bool quiet=False) -> bool
        requestOnce(ArClientBase self, char const * name, ArNetPacket packet=None) -> bool
        requestOnce(ArClientBase self, char const * name) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnce(self, name, packet, quiet)


    def requestOnceUdp(self, name, packet=None, quiet=False):
        """
        requestOnceUdp(ArClientBase self, char const * name, ArNetPacket packet=None, bool quiet=False) -> bool
        requestOnceUdp(ArClientBase self, char const * name, ArNetPacket packet=None) -> bool
        requestOnceUdp(ArClientBase self, char const * name) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnceUdp(self, name, packet, quiet)


    def requestOnceWithString(self, name, str):
        """requestOnceWithString(ArClientBase self, char const * name, char const * str) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestOnceWithString(self, name, str)


    def requestOnceWithInt16(self, name, val):
        """requestOnceWithInt16(ArClientBase self, char const * name, ArTypes::Byte2 val) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestOnceWithInt16(self, name, val)


    def requestOnceWithInt32(self, name, val):
        """requestOnceWithInt32(ArClientBase self, char const * name, ArTypes::Byte4 val) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestOnceWithInt32(self, name, val)


    def requestOnceWithDouble(self, name, val):
        """requestOnceWithDouble(ArClientBase self, char const * name, double val) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestOnceWithDouble(self, name, val)


    def dataExists(self, name):
        """dataExists(ArClientBase self, char const * name) -> bool"""
        return _ArNetworkingPy.ArClientBase_dataExists(self, name)


    def getHost(self):
        """getHost(ArClientBase self) -> char const *"""
        return _ArNetworkingPy.ArClientBase_getHost(self)


    def getPort(self):
        """getPort(ArClientBase self) -> int"""
        return _ArNetworkingPy.ArClientBase_getPort(self)


    def setServerKey(self, serverKey, log=True):
        """
        setServerKey(ArClientBase self, char const * serverKey, bool log=True)
        setServerKey(ArClientBase self, char const * serverKey)
        """
        return _ArNetworkingPy.ArClientBase_setServerKey(self, serverKey, log)


    def enforceProtocolVersion(self, protocolVersion, log=True):
        """
        enforceProtocolVersion(ArClientBase self, char const * protocolVersion, bool log=True)
        enforceProtocolVersion(ArClientBase self, char const * protocolVersion)
        """
        return _ArNetworkingPy.ArClientBase_enforceProtocolVersion(self, protocolVersion, log)


    def enforceType(self, type, log=True):
        """
        enforceType(ArClientBase self, ArServerCommands::Type type, bool log=True)
        enforceType(ArClientBase self, ArServerCommands::Type type)
        """
        return _ArNetworkingPy.ArClientBase_enforceType(self, type, log)


    def getLastPacketReceived(self):
        """getLastPacketReceived(ArClientBase self) -> ArTime"""
        return _ArNetworkingPy.ArClientBase_getLastPacketReceived(self)


    def setBackupTimeout(self, timeoutInMins):
        """setBackupTimeout(ArClientBase self, double timeoutInMins)"""
        return _ArNetworkingPy.ArClientBase_setBackupTimeout(self, timeoutInMins)


    def run(self):
        """run(ArClientBase self)"""
        return _ArNetworkingPy.ArClientBase_run(self)


    def runAsync(self):
        """runAsync(ArClientBase self)"""
        return _ArNetworkingPy.ArClientBase_runAsync(self)


    def stopRunning(self):
        """stopRunning(ArClientBase self)"""
        return _ArNetworkingPy.ArClientBase_stopRunning(self)


    def isStopped(self):
        """isStopped(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isStopped(self)


    def logDataList(self):
        """logDataList(ArClientBase self)"""
        return _ArNetworkingPy.ArClientBase_logDataList(self)


    def addCycleCallback(self, functor):
        """addCycleCallback(ArClientBase self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_addCycleCallback(self, functor)


    def remCycleCallback(self, functor):
        """remCycleCallback(ArClientBase self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_remCycleCallback(self, functor)


    def sendPacketTcp(self, packet):
        """sendPacketTcp(ArClientBase self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientBase_sendPacketTcp(self, packet)


    def sendPacketUdp(self, packet):
        """sendPacketUdp(ArClientBase self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientBase_sendPacketUdp(self, packet)


    def setConnectTimeoutTime(self, sec):
        """setConnectTimeoutTime(ArClientBase self, int sec)"""
        return _ArNetworkingPy.ArClientBase_setConnectTimeoutTime(self, sec)


    def getConnectTimeoutTime(self):
        """getConnectTimeoutTime(ArClientBase self) -> int"""
        return _ArNetworkingPy.ArClientBase_getConnectTimeoutTime(self)


    def logTracking(self, terse):
        """logTracking(ArClientBase self, bool terse)"""
        return _ArNetworkingPy.ArClientBase_logTracking(self, terse)


    def resetTracking(self):
        """resetTracking(ArClientBase self)"""
        return _ArNetworkingPy.ArClientBase_resetTracking(self)


    def addServerShutdownCB(self, *args):
        """
        addServerShutdownCB(ArClientBase self, ArFunctor functor, ArListPos::Pos position)
        addServerShutdownCB(ArClientBase self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientBase_addServerShutdownCB(self, *args)


    def remServerShutdownCB(self, functor):
        """remServerShutdownCB(ArClientBase self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_remServerShutdownCB(self, functor)


    def addDisconnectOnErrorCB(self, *args):
        """
        addDisconnectOnErrorCB(ArClientBase self, ArFunctor functor, ArListPos::Pos position)
        addDisconnectOnErrorCB(ArClientBase self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientBase_addDisconnectOnErrorCB(self, *args)


    def remDisconnectOnErrorCB(self, functor):
        """remDisconnectOnErrorCB(ArClientBase self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_remDisconnectOnErrorCB(self, functor)


    def loopOnce(self):
        """loopOnce(ArClientBase self)"""
        return _ArNetworkingPy.ArClientBase_loopOnce(self)


    def processPacket(self, packet, tcp):
        """processPacket(ArClientBase self, ArNetPacket packet, bool tcp)"""
        return _ArNetworkingPy.ArClientBase_processPacket(self, packet, tcp)


    def processPacketUdp(self, packet, sin):
        """processPacketUdp(ArClientBase self, ArNetPacket packet, sockaddr_in * sin)"""
        return _ArNetworkingPy.ArClientBase_processPacketUdp(self, packet, sin)


    def setTcpOnlyFromServer(self):
        """setTcpOnlyFromServer(ArClientBase self)"""
        return _ArNetworkingPy.ArClientBase_setTcpOnlyFromServer(self)


    def setTcpOnlyToServer(self):
        """setTcpOnlyToServer(ArClientBase self)"""
        return _ArNetworkingPy.ArClientBase_setTcpOnlyToServer(self)


    def isTcpOnlyFromServer(self):
        """isTcpOnlyFromServer(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isTcpOnlyFromServer(self)


    def isTcpOnlyToServer(self):
        """isTcpOnlyToServer(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isTcpOnlyToServer(self)


    def getClientKey(self, key):
        """getClientKey(ArClientBase self, unsigned char [ArClientBase::CLIENT_KEY_LENGTH] key)"""
        return _ArNetworkingPy.ArClientBase_getClientKey(self, key)


    def startNonBlockingDisconnect(self):
        """startNonBlockingDisconnect(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_startNonBlockingDisconnect(self)


    def finishNonBlockingDisconnect(self):
        """finishNonBlockingDisconnect(ArClientBase self)"""
        return _ArNetworkingPy.ArClientBase_finishNonBlockingDisconnect(self)


    def getName(self, *args):
        """
        getName(ArClientBase self, ArNetPacket packet, bool internalCall=False) -> char const
        getName(ArClientBase self, ArNetPacket packet) -> char const
        getName(ArClientBase self, unsigned int command, bool internalCall=False) -> char const
        getName(ArClientBase self, unsigned int command) -> char const *
        """
        return _ArNetworkingPy.ArClientBase_getName(self, *args)


    def runThread(self, arg):
        """runThread(ArClientBase self, void * arg) -> void *"""
        return _ArNetworkingPy.ArClientBase_runThread(self, arg)


    def getTcpAddr(self):
        """getTcpAddr(ArClientBase self) -> in_addr *"""
        return _ArNetworkingPy.ArClientBase_getTcpAddr(self)


    def internalBlockingConnect(self, host, port, log, user, password, tcpSocket, openOnIP=None):
        """
        internalBlockingConnect(ArClientBase self, char const * host, int port, bool log, char const * user, char const * password, ArSocket tcpSocket, char const * openOnIP=None) -> bool
        internalBlockingConnect(ArClientBase self, char const * host, int port, bool log, char const * user, char const * password, ArSocket tcpSocket) -> bool
        """
        return _ArNetworkingPy.ArClientBase_internalBlockingConnect(self, host, port, log, user, password, tcpSocket, openOnIP)


    def internalNonBlockingConnectStart(self, host, port, log, user, password, tcpSocket, openOnIP=None):
        """
        internalNonBlockingConnectStart(ArClientBase self, char const * host, int port, bool log, char const * user, char const * password, ArSocket tcpSocket, char const * openOnIP=None) -> ArClientBase::NonBlockingConnectReturn
        internalNonBlockingConnectStart(ArClientBase self, char const * host, int port, bool log, char const * user, char const * password, ArSocket tcpSocket) -> ArClientBase::NonBlockingConnectReturn
        """
        return _ArNetworkingPy.ArClientBase_internalNonBlockingConnectStart(self, host, port, log, user, password, tcpSocket, openOnIP)


    def internalNonBlockingConnectContinue(self):
        """internalNonBlockingConnectContinue(ArClientBase self) -> ArClientBase::NonBlockingConnectReturn"""
        return _ArNetworkingPy.ArClientBase_internalNonBlockingConnectContinue(self)


    def getTcpSocket(self):
        """getTcpSocket(ArClientBase self) -> ArSocket"""
        return _ArNetworkingPy.ArClientBase_getTcpSocket(self)


    def getUdpSocket(self):
        """getUdpSocket(ArClientBase self) -> ArSocket"""
        return _ArNetworkingPy.ArClientBase_getUdpSocket(self)


    def getDataMap(self):
        """getDataMap(ArClientBase self) -> std::map< unsigned int,ArClientData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArClientData * > > > const *"""
        return _ArNetworkingPy.ArClientBase_getDataMap(self)


    def findCommandFromName(self, name):
        """findCommandFromName(ArClientBase self, char const * name) -> unsigned int"""
        return _ArNetworkingPy.ArClientBase_findCommandFromName(self, name)


    def requestByCommand(self, command, mSec, packet=None):
        """
        requestByCommand(ArClientBase self, unsigned int command, long mSec, ArNetPacket packet=None) -> bool
        requestByCommand(ArClientBase self, unsigned int command, long mSec) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestByCommand(self, command, mSec, packet)


    def requestStopByCommand(self, command):
        """requestStopByCommand(ArClientBase self, unsigned int command) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestStopByCommand(self, command)


    def requestOnceByCommand(self, command, packet=None):
        """
        requestOnceByCommand(ArClientBase self, unsigned int command, ArNetPacket packet=None) -> bool
        requestOnceByCommand(ArClientBase self, unsigned int command) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnceByCommand(self, command, packet)


    def requestOnceByCommandUdp(self, command, packet=None):
        """
        requestOnceByCommandUdp(ArClientBase self, unsigned int command, ArNetPacket packet=None) -> bool
        requestOnceByCommandUdp(ArClientBase self, unsigned int command) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnceByCommandUdp(self, command, packet)


    def getReceivedDataList(self):
        """getReceivedDataList(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getReceivedDataList(self)


    def getReceivedArgRetList(self):
        """getReceivedArgRetList(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getReceivedArgRetList(self)


    def getReceivedGroupAndFlagsList(self):
        """getReceivedGroupAndFlagsList(ArClientBase self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getReceivedGroupAndFlagsList(self)


    def getRejected(self):
        """getRejected(ArClientBase self) -> int"""
        return _ArNetworkingPy.ArClientBase_getRejected(self)


    def getRejectedString(self):
        """getRejectedString(ArClientBase self) -> char const *"""
        return _ArNetworkingPy.ArClientBase_getRejectedString(self)

ArClientBase_swigregister = _ArNetworkingPy.ArClientBase_swigregister
ArClientBase_swigregister(ArClientBase)

class ArClientCommands(_object):
    """Proxy of C++ ArClientCommands class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientCommands, name)
    __repr__ = _swig_repr
    SHUTDOWN = _ArNetworkingPy.ArClientCommands_SHUTDOWN
    INTRODUCTION = _ArNetworkingPy.ArClientCommands_INTRODUCTION
    UDP_INTRODUCTION = _ArNetworkingPy.ArClientCommands_UDP_INTRODUCTION
    UDP_CONFIRMATION = _ArNetworkingPy.ArClientCommands_UDP_CONFIRMATION
    TCP_ONLY = _ArNetworkingPy.ArClientCommands_TCP_ONLY
    LIST = _ArNetworkingPy.ArClientCommands_LIST
    REQUEST = _ArNetworkingPy.ArClientCommands_REQUEST
    REQUESTSTOP = _ArNetworkingPy.ArClientCommands_REQUESTSTOP

    def __init__(self):
        """__init__(ArClientCommands self) -> ArClientCommands"""
        this = _ArNetworkingPy.new_ArClientCommands()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientCommands
    __del__ = lambda self: None
ArClientCommands_swigregister = _ArNetworkingPy.ArClientCommands_swigregister
ArClientCommands_swigregister(ArClientCommands)

class ArClientFileListerItem(_object):
    """Proxy of C++ ArClientFileListerItem class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileListerItem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileListerItem, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArClientFileListerItem self, char const * name, time_t atime, time_t mtime, ArTypes::UByte4 size) -> ArClientFileListerItem
        __init__(ArClientFileListerItem self, ArClientFileListerItem item) -> ArClientFileListerItem
        """
        this = _ArNetworkingPy.new_ArClientFileListerItem(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileListerItem
    __del__ = lambda self: None

    def getName(self):
        """getName(ArClientFileListerItem self) -> char const *"""
        return _ArNetworkingPy.ArClientFileListerItem_getName(self)


    def getLastAccessedTime(self):
        """getLastAccessedTime(ArClientFileListerItem self) -> time_t"""
        return _ArNetworkingPy.ArClientFileListerItem_getLastAccessedTime(self)


    def getLastModifiedTime(self):
        """getLastModifiedTime(ArClientFileListerItem self) -> time_t"""
        return _ArNetworkingPy.ArClientFileListerItem_getLastModifiedTime(self)


    def getSize(self):
        """getSize(ArClientFileListerItem self) -> ArTypes::UByte4"""
        return _ArNetworkingPy.ArClientFileListerItem_getSize(self)

ArClientFileListerItem_swigregister = _ArNetworkingPy.ArClientFileListerItem_swigregister
ArClientFileListerItem_swigregister(ArClientFileListerItem)

class ArClientFileLister(_object):
    """Proxy of C++ ArClientFileLister class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileLister, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileLister, name)
    __repr__ = _swig_repr

    def __init__(self, client):
        """__init__(ArClientFileLister self, ArClientBase client) -> ArClientFileLister"""
        this = _ArNetworkingPy.new_ArClientFileLister(client)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileLister
    __del__ = lambda self: None

    def isAvailable(self):
        """isAvailable(ArClientFileLister self) -> bool"""
        return _ArNetworkingPy.ArClientFileLister_isAvailable(self)


    def changeToTopDir(self):
        """changeToTopDir(ArClientFileLister self)"""
        return _ArNetworkingPy.ArClientFileLister_changeToTopDir(self)


    def changeToDir(self, dir):
        """changeToDir(ArClientFileLister self, char const * dir)"""
        return _ArNetworkingPy.ArClientFileLister_changeToDir(self, dir)


    def upOneDir(self):
        """upOneDir(ArClientFileLister self)"""
        return _ArNetworkingPy.ArClientFileLister_upOneDir(self)


    def changeToAbsDir(self, dir):
        """changeToAbsDir(ArClientFileLister self, char const * dir)"""
        return _ArNetworkingPy.ArClientFileLister_changeToAbsDir(self, dir)


    def getCurrentDir(self):
        """getCurrentDir(ArClientFileLister self) -> char const *"""
        return _ArNetworkingPy.ArClientFileLister_getCurrentDir(self)


    def getWaitingForDir(self):
        """getWaitingForDir(ArClientFileLister self) -> char const *"""
        return _ArNetworkingPy.ArClientFileLister_getWaitingForDir(self)


    def getDirectories(self):
        """getDirectories(ArClientFileLister self) -> std::list< ArClientFileListerItem,std::allocator< ArClientFileListerItem > >"""
        return _ArNetworkingPy.ArClientFileLister_getDirectories(self)


    def getFiles(self):
        """getFiles(ArClientFileLister self) -> std::list< ArClientFileListerItem,std::allocator< ArClientFileListerItem > >"""
        return _ArNetworkingPy.ArClientFileLister_getFiles(self)


    def addUpdatedCallback(self, *args):
        """
        addUpdatedCallback(ArClientFileLister self, ArFunctor1_Int functor, ArListPos::Pos position)
        addUpdatedCallback(ArClientFileLister self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientFileLister_addUpdatedCallback(self, *args)


    def remUpdatedCallback(self, functor):
        """remUpdatedCallback(ArClientFileLister self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientFileLister_remUpdatedCallback(self, functor)


    def getLastUpdated(self):
        """getLastUpdated(ArClientFileLister self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileLister_getLastUpdated(self)


    def getLastRequested(self):
        """getLastRequested(ArClientFileLister self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileLister_getLastRequested(self)


    def log(self, withTimes):
        """log(ArClientFileLister self, bool withTimes)"""
        return _ArNetworkingPy.ArClientFileLister_log(self, withTimes)

ArClientFileLister_swigregister = _ArNetworkingPy.ArClientFileLister_swigregister
ArClientFileLister_swigregister(ArClientFileLister)

class ArClientFileToClient(_object):
    """Proxy of C++ ArClientFileToClient class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileToClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileToClient, name)
    __repr__ = _swig_repr

    def __init__(self, client):
        """__init__(ArClientFileToClient self, ArClientBase client) -> ArClientFileToClient"""
        this = _ArNetworkingPy.new_ArClientFileToClient(client)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileToClient
    __del__ = lambda self: None

    def isAvailable(self):
        """isAvailable(ArClientFileToClient self) -> bool"""
        return _ArNetworkingPy.ArClientFileToClient_isAvailable(self)


    def isAvailableSetTimestamp(self):
        """isAvailableSetTimestamp(ArClientFileToClient self) -> bool"""
        return _ArNetworkingPy.ArClientFileToClient_isAvailableSetTimestamp(self)


    def getFileFromDirectory(self, directory, fileName, clientFileName, isSetTimestamp=False):
        """
        getFileFromDirectory(ArClientFileToClient self, char const * directory, char const * fileName, char const * clientFileName, bool isSetTimestamp=False) -> bool
        getFileFromDirectory(ArClientFileToClient self, char const * directory, char const * fileName, char const * clientFileName) -> bool
        """
        return _ArNetworkingPy.ArClientFileToClient_getFileFromDirectory(self, directory, fileName, clientFileName, isSetTimestamp)


    def cancelGet(self):
        """cancelGet(ArClientFileToClient self)"""
        return _ArNetworkingPy.ArClientFileToClient_cancelGet(self)


    def isWaitingForFile(self):
        """isWaitingForFile(ArClientFileToClient self) -> bool"""
        return _ArNetworkingPy.ArClientFileToClient_isWaitingForFile(self)


    def getDirectory(self):
        """getDirectory(ArClientFileToClient self) -> char const *"""
        return _ArNetworkingPy.ArClientFileToClient_getDirectory(self)


    def getFileName(self):
        """getFileName(ArClientFileToClient self) -> char const *"""
        return _ArNetworkingPy.ArClientFileToClient_getFileName(self)


    def getClientFileName(self):
        """getClientFileName(ArClientFileToClient self) -> char const *"""
        return _ArNetworkingPy.ArClientFileToClient_getClientFileName(self)


    def addFileReceivedCallback(self, *args):
        """
        addFileReceivedCallback(ArClientFileToClient self, ArFunctor1_Int functor, ArListPos::Pos position)
        addFileReceivedCallback(ArClientFileToClient self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientFileToClient_addFileReceivedCallback(self, *args)


    def remFileReceivedCallback(self, functor):
        """remFileReceivedCallback(ArClientFileToClient self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientFileToClient_remFileReceivedCallback(self, functor)


    def getLastReceived(self):
        """getLastReceived(ArClientFileToClient self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileToClient_getLastReceived(self)


    def getLastRequested(self):
        """getLastRequested(ArClientFileToClient self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileToClient_getLastRequested(self)

ArClientFileToClient_swigregister = _ArNetworkingPy.ArClientFileToClient_swigregister
ArClientFileToClient_swigregister(ArClientFileToClient)

class ArClientFileFromClient(_object):
    """Proxy of C++ ArClientFileFromClient class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileFromClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileFromClient, name)
    __repr__ = _swig_repr

    def __init__(self, client):
        """__init__(ArClientFileFromClient self, ArClientBase client) -> ArClientFileFromClient"""
        this = _ArNetworkingPy.new_ArClientFileFromClient(client)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileFromClient
    __del__ = lambda self: None

    def isAvailable(self):
        """isAvailable(ArClientFileFromClient self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailable(self)


    def isAvailableSlow(self):
        """isAvailableSlow(ArClientFileFromClient self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailableSlow(self)


    def isAvailableFast(self):
        """isAvailableFast(ArClientFileFromClient self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailableFast(self)


    def isAvailableSetTimestamp(self):
        """isAvailableSetTimestamp(ArClientFileFromClient self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailableSetTimestamp(self)

    SPEED_AUTO = _ArNetworkingPy.ArClientFileFromClient_SPEED_AUTO
    SPEED_FAST = _ArNetworkingPy.ArClientFileFromClient_SPEED_FAST
    SPEED_SLOW = _ArNetworkingPy.ArClientFileFromClient_SPEED_SLOW

    def putFileToDirectory(self, *args):
        """
        putFileToDirectory(ArClientFileFromClient self, char const * directory, char const * fileName, char const * clientFileName, ArClientFileFromClient::SendSpeed sendSpeed, bool isSetTimestamp=False) -> bool
        putFileToDirectory(ArClientFileFromClient self, char const * directory, char const * fileName, char const * clientFileName, ArClientFileFromClient::SendSpeed sendSpeed) -> bool
        putFileToDirectory(ArClientFileFromClient self, char const * directory, char const * fileName, char const * clientFileName) -> bool
        """
        return _ArNetworkingPy.ArClientFileFromClient_putFileToDirectory(self, *args)


    def cancelPut(self):
        """cancelPut(ArClientFileFromClient self)"""
        return _ArNetworkingPy.ArClientFileFromClient_cancelPut(self)


    def isWaitingForReturn(self):
        """isWaitingForReturn(ArClientFileFromClient self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isWaitingForReturn(self)


    def getDirectory(self):
        """getDirectory(ArClientFileFromClient self) -> char const *"""
        return _ArNetworkingPy.ArClientFileFromClient_getDirectory(self)


    def getFileName(self):
        """getFileName(ArClientFileFromClient self) -> char const *"""
        return _ArNetworkingPy.ArClientFileFromClient_getFileName(self)


    def getClientFileName(self):
        """getClientFileName(ArClientFileFromClient self) -> char const *"""
        return _ArNetworkingPy.ArClientFileFromClient_getClientFileName(self)


    def addFileSentCallback(self, *args):
        """
        addFileSentCallback(ArClientFileFromClient self, ArFunctor1_Int functor, ArListPos::Pos position)
        addFileSentCallback(ArClientFileFromClient self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientFileFromClient_addFileSentCallback(self, *args)


    def remFileSentCallback(self, functor):
        """remFileSentCallback(ArClientFileFromClient self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientFileFromClient_remFileSentCallback(self, functor)


    def getLastCompletedSend(self):
        """getLastCompletedSend(ArClientFileFromClient self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileFromClient_getLastCompletedSend(self)


    def getLastStartedSend(self):
        """getLastStartedSend(ArClientFileFromClient self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileFromClient_getLastStartedSend(self)

ArClientFileFromClient_swigregister = _ArNetworkingPy.ArClientFileFromClient_swigregister
ArClientFileFromClient_swigregister(ArClientFileFromClient)

class ArClientDeleteFileOnServer(_object):
    """Proxy of C++ ArClientDeleteFileOnServer class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientDeleteFileOnServer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientDeleteFileOnServer, name)
    __repr__ = _swig_repr

    def __init__(self, client):
        """__init__(ArClientDeleteFileOnServer self, ArClientBase client) -> ArClientDeleteFileOnServer"""
        this = _ArNetworkingPy.new_ArClientDeleteFileOnServer(client)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientDeleteFileOnServer
    __del__ = lambda self: None

    def isAvailable(self):
        """isAvailable(ArClientDeleteFileOnServer self) -> bool"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_isAvailable(self)


    def deleteFileFromDirectory(self, directory, fileName):
        """deleteFileFromDirectory(ArClientDeleteFileOnServer self, char const * directory, char const * fileName) -> bool"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_deleteFileFromDirectory(self, directory, fileName)


    def isWaitingForReturn(self):
        """isWaitingForReturn(ArClientDeleteFileOnServer self) -> bool"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_isWaitingForReturn(self)


    def getDirectory(self):
        """getDirectory(ArClientDeleteFileOnServer self) -> char const *"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getDirectory(self)


    def getFileName(self):
        """getFileName(ArClientDeleteFileOnServer self) -> char const *"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getFileName(self)


    def addFileDeletedCallback(self, *args):
        """
        addFileDeletedCallback(ArClientDeleteFileOnServer self, ArFunctor1_Int functor, ArListPos::Pos position)
        addFileDeletedCallback(ArClientDeleteFileOnServer self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientDeleteFileOnServer_addFileDeletedCallback(self, *args)


    def remFileDeletedCallback(self, functor):
        """remFileDeletedCallback(ArClientDeleteFileOnServer self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_remFileDeletedCallback(self, functor)


    def getLastCompletedSend(self):
        """getLastCompletedSend(ArClientDeleteFileOnServer self) -> ArTime"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getLastCompletedSend(self)


    def getLastStartedSend(self):
        """getLastStartedSend(ArClientDeleteFileOnServer self) -> ArTime"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getLastStartedSend(self)

ArClientDeleteFileOnServer_swigregister = _ArNetworkingPy.ArClientDeleteFileOnServer_swigregister
ArClientDeleteFileOnServer_swigregister(ArClientDeleteFileOnServer)

class ArClientHandlerConfig(_object):
    """Proxy of C++ ArClientHandlerConfig class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientHandlerConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientHandlerConfig, name)
    __repr__ = _swig_repr

    def __init__(self, client, ignoreBounds=False, robotName=None, logPrefix=None):
        """
        __init__(ArClientHandlerConfig self, ArClientBase client, bool ignoreBounds=False, char const * robotName=None, char const * logPrefix=None) -> ArClientHandlerConfig
        __init__(ArClientHandlerConfig self, ArClientBase client, bool ignoreBounds=False, char const * robotName=None) -> ArClientHandlerConfig
        __init__(ArClientHandlerConfig self, ArClientBase client, bool ignoreBounds=False) -> ArClientHandlerConfig
        __init__(ArClientHandlerConfig self, ArClientBase client) -> ArClientHandlerConfig
        """
        this = _ArNetworkingPy.new_ArClientHandlerConfig(client, ignoreBounds, robotName, logPrefix)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientHandlerConfig
    __del__ = lambda self: None

    def requestConfigFromServer(self):
        """requestConfigFromServer(ArClientHandlerConfig self)"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestConfigFromServer(self)


    def reloadConfigOnServer(self):
        """reloadConfigOnServer(ArClientHandlerConfig self)"""
        return _ArNetworkingPy.ArClientHandlerConfig_reloadConfigOnServer(self)


    def getConfigCopy(self):
        """getConfigCopy(ArClientHandlerConfig self) -> ArConfig"""
        return _ArNetworkingPy.ArClientHandlerConfig_getConfigCopy(self)


    def addGotConfigCB(self, *args):
        """
        addGotConfigCB(ArClientHandlerConfig self, ArFunctor functor, ArListPos::Pos position)
        addGotConfigCB(ArClientHandlerConfig self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addGotConfigCB(self, *args)


    def remGotConfigCB(self, functor):
        """remGotConfigCB(ArClientHandlerConfig self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remGotConfigCB(self, functor)


    def addSaveConfigSucceededCB(self, *args):
        """
        addSaveConfigSucceededCB(ArClientHandlerConfig self, ArFunctor functor, ArListPos::Pos position)
        addSaveConfigSucceededCB(ArClientHandlerConfig self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addSaveConfigSucceededCB(self, *args)


    def remSaveConfigSucceededCB(self, functor):
        """remSaveConfigSucceededCB(ArClientHandlerConfig self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remSaveConfigSucceededCB(self, functor)


    def addSaveConfigFailedCB(self, *args):
        """
        addSaveConfigFailedCB(ArClientHandlerConfig self, ArFunctor1_CString functor, ArListPos::Pos position)
        addSaveConfigFailedCB(ArClientHandlerConfig self, ArFunctor1_CString functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addSaveConfigFailedCB(self, *args)


    def remSaveConfigFailedCB(self, functor):
        """remSaveConfigFailedCB(ArClientHandlerConfig self, ArFunctor1_CString functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remSaveConfigFailedCB(self, functor)


    def haveGottenConfig(self):
        """haveGottenConfig(ArClientHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveGottenConfig(self)


    def saveConfigToServer(self, *args):
        """
        saveConfigToServer(ArClientHandlerConfig self)
        saveConfigToServer(ArClientHandlerConfig self, ArConfig config, std::set< std::string,ArStrCaseCmpOp,std::allocator< std::string > > const * ignoreTheseSections=None)
        saveConfigToServer(ArClientHandlerConfig self, ArConfig config)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_saveConfigToServer(self, *args)


    def haveRequestedDefaults(self):
        """haveRequestedDefaults(ArClientHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveRequestedDefaults(self)


    def haveGottenDefaults(self):
        """haveGottenDefaults(ArClientHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveGottenDefaults(self)


    def canRequestDefaults(self):
        """canRequestDefaults(ArClientHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_canRequestDefaults(self)


    def requestDefaultConfigFromServer(self):
        """requestDefaultConfigFromServer(ArClientHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestDefaultConfigFromServer(self)


    def getDefaultConfig(self):
        """getDefaultConfig(ArClientHandlerConfig self) -> ArConfig"""
        return _ArNetworkingPy.ArClientHandlerConfig_getDefaultConfig(self)


    def requestConfigDefaults(self):
        """requestConfigDefaults(ArClientHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestConfigDefaults(self)


    def requestSectionDefaults(self, section):
        """requestSectionDefaults(ArClientHandlerConfig self, char const * section) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestSectionDefaults(self, section)


    def addGotConfigDefaultsCB(self, *args):
        """
        addGotConfigDefaultsCB(ArClientHandlerConfig self, ArFunctor functor, ArListPos::Pos position)
        addGotConfigDefaultsCB(ArClientHandlerConfig self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addGotConfigDefaultsCB(self, *args)


    def remGotConfigDefaultsCB(self, functor):
        """remGotConfigDefaultsCB(ArClientHandlerConfig self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remGotConfigDefaultsCB(self, functor)


    def isLastEditablePriorityAvailable(self):
        """isLastEditablePriorityAvailable(ArClientHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_isLastEditablePriorityAvailable(self)


    def requestLastEditablePriorityFromServer(self):
        """requestLastEditablePriorityFromServer(ArClientHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestLastEditablePriorityFromServer(self)


    def haveGottenLastEditablePriority(self):
        """haveGottenLastEditablePriority(ArClientHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveGottenLastEditablePriority(self)


    def getLastEditablePriority(self):
        """getLastEditablePriority(ArClientHandlerConfig self) -> ArPriority::Priority"""
        return _ArNetworkingPy.ArClientHandlerConfig_getLastEditablePriority(self)


    def addGotLastEditablePriorityCB(self, functor, position=50):
        """
        addGotLastEditablePriorityCB(ArClientHandlerConfig self, ArFunctor functor, int position=50)
        addGotLastEditablePriorityCB(ArClientHandlerConfig self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addGotLastEditablePriorityCB(self, functor, position)


    def remGotLastEditablePriorityCB(self, functor):
        """remGotLastEditablePriorityCB(ArClientHandlerConfig self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remGotLastEditablePriorityCB(self, functor)


    def getConfig(self):
        """getConfig(ArClientHandlerConfig self) -> ArConfig"""
        return _ArNetworkingPy.ArClientHandlerConfig_getConfig(self)


    def lock(self):
        """lock(ArClientHandlerConfig self) -> int"""
        return _ArNetworkingPy.ArClientHandlerConfig_lock(self)


    def tryLock(self):
        """tryLock(ArClientHandlerConfig self) -> int"""
        return _ArNetworkingPy.ArClientHandlerConfig_tryLock(self)


    def unlock(self):
        """unlock(ArClientHandlerConfig self) -> int"""
        return _ArNetworkingPy.ArClientHandlerConfig_unlock(self)


    def setQuiet(self, isQuiet):
        """setQuiet(ArClientHandlerConfig self, bool isQuiet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_setQuiet(self, isQuiet)

ArClientHandlerConfig_swigregister = _ArNetworkingPy.ArClientHandlerConfig_swigregister
ArClientHandlerConfig_swigregister(ArClientHandlerConfig)

class ArClientSimpleConnector(_object):
    """Proxy of C++ ArClientSimpleConnector class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientSimpleConnector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientSimpleConnector, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArClientSimpleConnector self, ArArgumentParser parser) -> ArClientSimpleConnector
        __init__(ArClientSimpleConnector self, int * argc) -> ArClientSimpleConnector
        __init__(ArClientSimpleConnector self, ArArgumentBuilder arguments) -> ArClientSimpleConnector
        """
        this = _ArNetworkingPy.new_ArClientSimpleConnector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientSimpleConnector
    __del__ = lambda self: None

    def connectClient(self, client, log=True):
        """
        connectClient(ArClientSimpleConnector self, ArClientBase client, bool log=True) -> bool
        connectClient(ArClientSimpleConnector self, ArClientBase client) -> bool
        """
        return _ArNetworkingPy.ArClientSimpleConnector_connectClient(self, client, log)


    def parseArgs(self, *args):
        """
        parseArgs(ArClientSimpleConnector self) -> bool
        parseArgs(ArClientSimpleConnector self, ArArgumentParser parser) -> bool
        """
        return _ArNetworkingPy.ArClientSimpleConnector_parseArgs(self, *args)


    def logOptions(self):
        """logOptions(ArClientSimpleConnector self)"""
        return _ArNetworkingPy.ArClientSimpleConnector_logOptions(self)

ArClientSimpleConnector_swigregister = _ArNetworkingPy.ArClientSimpleConnector_swigregister
ArClientSimpleConnector_swigregister(ArClientSimpleConnector)

class ArHybridForwarderVideo(AriaPy.ArCameraCollectionItem):
    """Proxy of C++ ArHybridForwarderVideo class."""

    __swig_setmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArHybridForwarderVideo, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArHybridForwarderVideo, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArHybridForwarderVideo self, ArServerBase server, ArClientBase client) -> ArHybridForwarderVideo
        __init__(ArHybridForwarderVideo self, ArServerBase server, char const * hostname, int port=7070) -> ArHybridForwarderVideo
        __init__(ArHybridForwarderVideo self, ArServerBase server, char const * hostname) -> ArHybridForwarderVideo
        __init__(ArHybridForwarderVideo self, ArServerBase server) -> ArHybridForwarderVideo
        """
        this = _ArNetworkingPy.new_ArHybridForwarderVideo(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArHybridForwarderVideo
    __del__ = lambda self: None

    def isForwardingVideo(self):
        """isForwardingVideo(ArHybridForwarderVideo self) -> bool"""
        return _ArNetworkingPy.ArHybridForwarderVideo_isForwardingVideo(self)


    def getCameraName(self):
        """getCameraName(ArHybridForwarderVideo self) -> char const *"""
        return _ArNetworkingPy.ArHybridForwarderVideo_getCameraName(self)


    def setCameraName(self, cameraName):
        """setCameraName(ArHybridForwarderVideo self, char const * cameraName)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_setCameraName(self, cameraName)


    def addToCameraCollection(self, collection):
        """addToCameraCollection(ArHybridForwarderVideo self, ArCameraCollection collection)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_addToCameraCollection(self, collection)


    def sendVideoSize(self, client, packet):
        """sendVideoSize(ArHybridForwarderVideo self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_sendVideoSize(self, client, packet)


    def sendVideo(self, client, packet):
        """sendVideo(ArHybridForwarderVideo self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_sendVideo(self, client, packet)


    def receiveVideoSize(self, packet):
        """receiveVideoSize(ArHybridForwarderVideo self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_receiveVideoSize(self, packet)


    def receiveVideo(self, packet):
        """receiveVideo(ArHybridForwarderVideo self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_receiveVideo(self, packet)


    def clientCycleCallback(self):
        """clientCycleCallback(ArHybridForwarderVideo self)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_clientCycleCallback(self)


    def setVideoRequestTime(self, *args):
        """
        setVideoRequestTime(ArHybridForwarderVideo self, int ms)
        setVideoRequestTime(ArHybridForwarderVideo self) -> int
        """
        return _ArNetworkingPy.ArHybridForwarderVideo_setVideoRequestTime(self, *args)

ArHybridForwarderVideo_swigregister = _ArNetworkingPy.ArHybridForwarderVideo_swigregister
ArHybridForwarderVideo_swigregister(ArHybridForwarderVideo)

class ArNetPacketReceiverTcp(_object):
    """Proxy of C++ ArNetPacketReceiverTcp class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacketReceiverTcp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacketReceiverTcp, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ArNetPacketReceiverTcp self) -> ArNetPacketReceiverTcp"""
        this = _ArNetworkingPy.new_ArNetPacketReceiverTcp()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacketReceiverTcp
    __del__ = lambda self: None

    def setSocket(self, socket):
        """setSocket(ArNetPacketReceiverTcp self, ArSocket socket)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setSocket(self, socket)


    def getSocket(self):
        """getSocket(ArNetPacketReceiverTcp self) -> ArSocket"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_getSocket(self)


    def setProcessPacketCB(self, functor):
        """setProcessPacketCB(ArNetPacketReceiverTcp self, ArFunctor1< ArNetPacket * > * functor)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setProcessPacketCB(self, functor)


    def getProcessPacketCB(self):
        """getProcessPacketCB(ArNetPacketReceiverTcp self) -> ArFunctor1< ArNetPacket * > *"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_getProcessPacketCB(self)


    def setLoggingPrefix(self, loggingPrefix):
        """setLoggingPrefix(ArNetPacketReceiverTcp self, char const * loggingPrefix)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setLoggingPrefix(self, loggingPrefix)


    def readData(self):
        """readData(ArNetPacketReceiverTcp self) -> bool"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_readData(self)


    def setQuiet(self, quiet):
        """setQuiet(ArNetPacketReceiverTcp self, bool quiet)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setQuiet(self, quiet)


    def getQuiet(self):
        """getQuiet(ArNetPacketReceiverTcp self) -> bool"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_getQuiet(self)

ArNetPacketReceiverTcp_swigregister = _ArNetworkingPy.ArNetPacketReceiverTcp_swigregister
ArNetPacketReceiverTcp_swigregister(ArNetPacketReceiverTcp)

class ArNetPacketReceiverUdp(_object):
    """Proxy of C++ ArNetPacketReceiverUdp class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacketReceiverUdp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacketReceiverUdp, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ArNetPacketReceiverUdp self) -> ArNetPacketReceiverUdp"""
        this = _ArNetworkingPy.new_ArNetPacketReceiverUdp()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacketReceiverUdp
    __del__ = lambda self: None

    def setSocket(self, socket):
        """setSocket(ArNetPacketReceiverUdp self, ArSocket socket)"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_setSocket(self, socket)


    def getSocket(self):
        """getSocket(ArNetPacketReceiverUdp self) -> ArSocket"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_getSocket(self)


    def setProcessPacketCB(self, functor):
        """setProcessPacketCB(ArNetPacketReceiverUdp self, ArFunctor2< ArNetPacket *,sockaddr_in * > * functor)"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_setProcessPacketCB(self, functor)


    def getProcessPacketCB(self):
        """getProcessPacketCB(ArNetPacketReceiverUdp self) -> ArFunctor2< ArNetPacket *,sockaddr_in * > *"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_getProcessPacketCB(self)


    def readData(self):
        """readData(ArNetPacketReceiverUdp self) -> bool"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_readData(self)

ArNetPacketReceiverUdp_swigregister = _ArNetworkingPy.ArNetPacketReceiverUdp_swigregister
ArNetPacketReceiverUdp_swigregister(ArNetPacketReceiverUdp)

class ArNetPacketSenderTcp(_object):
    """Proxy of C++ ArNetPacketSenderTcp class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacketSenderTcp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacketSenderTcp, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ArNetPacketSenderTcp self) -> ArNetPacketSenderTcp"""
        this = _ArNetworkingPy.new_ArNetPacketSenderTcp()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacketSenderTcp
    __del__ = lambda self: None

    def setSocket(self, socket):
        """setSocket(ArNetPacketSenderTcp self, ArSocket socket)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setSocket(self, socket)


    def getSocket(self):
        """getSocket(ArNetPacketSenderTcp self) -> ArSocket"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_getSocket(self)


    def setBackupTimeout(self, connectionTimeoutInMins):
        """setBackupTimeout(ArNetPacketSenderTcp self, double connectionTimeoutInMins)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setBackupTimeout(self, connectionTimeoutInMins)


    def setDebugLogging(self, debugLogging):
        """setDebugLogging(ArNetPacketSenderTcp self, bool debugLogging)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setDebugLogging(self, debugLogging)


    def setLoggingPrefix(self, prefix):
        """setLoggingPrefix(ArNetPacketSenderTcp self, char const * prefix)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setLoggingPrefix(self, prefix)


    def sendPacket(self, *args):
        """
        sendPacket(ArNetPacketSenderTcp self, ArNetPacket packet, char const * loggingString)
        sendPacket(ArNetPacketSenderTcp self, ArNetPacket packet)
        """
        return _ArNetworkingPy.ArNetPacketSenderTcp_sendPacket(self, *args)


    def sendData(self):
        """sendData(ArNetPacketSenderTcp self) -> bool"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_sendData(self)

ArNetPacketSenderTcp_swigregister = _ArNetworkingPy.ArNetPacketSenderTcp_swigregister
ArNetPacketSenderTcp_swigregister(ArNetPacketSenderTcp)

class ArServerClient(_object):
    """Proxy of C++ ArServerClient class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerClient, name)
    __repr__ = _swig_repr
    STATE_SENT_INTRO = _ArNetworkingPy.ArServerClient_STATE_SENT_INTRO
    STATE_REJECTED = _ArNetworkingPy.ArServerClient_STATE_REJECTED
    STATE_CONNECTED = _ArNetworkingPy.ArServerClient_STATE_CONNECTED
    STATE_DISCONNECTED = _ArNetworkingPy.ArServerClient_STATE_DISCONNECTED

    def __init__(self, *args):
        """
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey, ArServerUserInfo userInfo=None, int rejecting=0, char const * rejectingString, bool debugLogging=False, char const * serverClientName, bool logPasswordFailureVerbosely=False, bool allowSlowPackets=True, bool allowIdlePackets=True, char const * enforceProtocolVersion, ArServerCommands::Type enforceType) -> ArServerClient
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey, ArServerUserInfo userInfo=None, int rejecting=0, char const * rejectingString, bool debugLogging=False, char const * serverClientName, bool logPasswordFailureVerbosely=False, bool allowSlowPackets=True, bool allowIdlePackets=True, char const * enforceProtocolVersion) -> ArServerClient
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey, ArServerUserInfo userInfo=None, int rejecting=0, char const * rejectingString, bool debugLogging=False, char const * serverClientName, bool logPasswordFailureVerbosely=False, bool allowSlowPackets=True, bool allowIdlePackets=True) -> ArServerClient
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey, ArServerUserInfo userInfo=None, int rejecting=0, char const * rejectingString, bool debugLogging=False, char const * serverClientName, bool logPasswordFailureVerbosely=False, bool allowSlowPackets=True) -> ArServerClient
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey, ArServerUserInfo userInfo=None, int rejecting=0, char const * rejectingString, bool debugLogging=False, char const * serverClientName, bool logPasswordFailureVerbosely=False) -> ArServerClient
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey, ArServerUserInfo userInfo=None, int rejecting=0, char const * rejectingString, bool debugLogging=False, char const * serverClientName) -> ArServerClient
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey, ArServerUserInfo userInfo=None, int rejecting=0, char const * rejectingString, bool debugLogging=False) -> ArServerClient
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey, ArServerUserInfo userInfo=None, int rejecting=0, char const * rejectingString) -> ArServerClient
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey, ArServerUserInfo userInfo=None, int rejecting=0) -> ArServerClient
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey, ArServerUserInfo userInfo=None) -> ArServerClient
        __init__(ArServerClient self, ArSocket tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2< bool,ArNetPacket *,sockaddr_in * > * sendUdpCallback, std::map< unsigned int,ArServerData *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,ArServerData * > > > * dataMap, char const * passwordKey, char const * serverKey) -> ArServerClient
        """
        this = _ArNetworkingPy.new_ArServerClient(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerClient
    __del__ = lambda self: None

    def tcpCallback(self):
        """tcpCallback(ArServerClient self) -> bool"""
        return _ArNetworkingPy.ArServerClient_tcpCallback(self)


    def slowPacketCallback(self):
        """slowPacketCallback(ArServerClient self) -> bool"""
        return _ArNetworkingPy.ArServerClient_slowPacketCallback(self)


    def idlePacketCallback(self):
        """idlePacketCallback(ArServerClient self) -> bool"""
        return _ArNetworkingPy.ArServerClient_idlePacketCallback(self)


    def setBackupTimeout(self, timeoutInMins):
        """setBackupTimeout(ArServerClient self, double timeoutInMins)"""
        return _ArNetworkingPy.ArServerClient_setBackupTimeout(self, timeoutInMins)


    def processPacket(self, packet, tcp=True):
        """
        processPacket(ArServerClient self, ArNetPacket packet, bool tcp=True)
        processPacket(ArServerClient self, ArNetPacket packet)
        """
        return _ArNetworkingPy.ArServerClient_processPacket(self, packet, tcp)


    def sendPacketTcp(self, packet):
        """sendPacketTcp(ArServerClient self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerClient_sendPacketTcp(self, packet)


    def sendPacketUdp(self, packet):
        """sendPacketUdp(ArServerClient self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerClient_sendPacketUdp(self, packet)


    def hasGroupAccess(self, group):
        """hasGroupAccess(ArServerClient self, char const * group) -> bool"""
        return _ArNetworkingPy.ArServerClient_hasGroupAccess(self, group)


    def broadcastPacketTcp(self, packet):
        """broadcastPacketTcp(ArServerClient self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerClient_broadcastPacketTcp(self, packet)


    def broadcastPacketUdp(self, packet):
        """broadcastPacketUdp(ArServerClient self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerClient_broadcastPacketUdp(self, packet)


    def logTracking(self, terse):
        """logTracking(ArServerClient self, bool terse)"""
        return _ArNetworkingPy.ArServerClient_logTracking(self, terse)


    def resetTracking(self):
        """resetTracking(ArServerClient self)"""
        return _ArNetworkingPy.ArServerClient_resetTracking(self)


    def getIPString(self):
        """getIPString(ArServerClient self) -> char const *"""
        return _ArNetworkingPy.ArServerClient_getIPString(self)


    def getIdentifier(self):
        """getIdentifier(ArServerClient self) -> ArServerClientIdentifier"""
        return _ArNetworkingPy.ArServerClient_getIdentifier(self)


    def setIdentifier(self, identifier):
        """setIdentifier(ArServerClient self, ArServerClientIdentifier identifier)"""
        return _ArNetworkingPy.ArServerClient_setIdentifier(self, identifier)


    def shutdown(self):
        """shutdown(ArServerClient self)"""
        return _ArNetworkingPy.ArServerClient_shutdown(self)


    def setUdpAddress(self, sin):
        """setUdpAddress(ArServerClient self, sockaddr_in * sin)"""
        return _ArNetworkingPy.ArServerClient_setUdpAddress(self, sin)


    def getUdpAddress(self):
        """getUdpAddress(ArServerClient self) -> sockaddr_in *"""
        return _ArNetworkingPy.ArServerClient_getUdpAddress(self)


    def getAuthKey(self):
        """getAuthKey(ArServerClient self) -> long"""
        return _ArNetworkingPy.ArServerClient_getAuthKey(self)


    def processAuthPacket(self, packet, sin):
        """processAuthPacket(ArServerClient self, ArNetPacket packet, sockaddr_in * sin)"""
        return _ArNetworkingPy.ArServerClient_processAuthPacket(self, packet, sin)


    def handleRequests(self):
        """handleRequests(ArServerClient self)"""
        return _ArNetworkingPy.ArServerClient_handleRequests(self)


    def getTcpSocket(self):
        """getTcpSocket(ArServerClient self) -> ArSocket"""
        return _ArNetworkingPy.ArServerClient_getTcpSocket(self)


    def forceDisconnect(self, quiet):
        """forceDisconnect(ArServerClient self, bool quiet)"""
        return _ArNetworkingPy.ArServerClient_forceDisconnect(self, quiet)


    def getFrequency(self, command):
        """getFrequency(ArServerClient self, ArTypes::UByte2 command) -> long"""
        return _ArNetworkingPy.ArServerClient_getFrequency(self, command)


    def useTcpOnly(self):
        """useTcpOnly(ArServerClient self)"""
        return _ArNetworkingPy.ArServerClient_useTcpOnly(self)


    def isTcpOnly(self):
        """isTcpOnly(ArServerClient self) -> bool"""
        return _ArNetworkingPy.ArServerClient_isTcpOnly(self)


    def getState(self):
        """getState(ArServerClient self) -> ArServerClient::ServerState"""
        return _ArNetworkingPy.ArServerClient_getState(self)


    def hasSlowPackets(self):
        """hasSlowPackets(ArServerClient self) -> bool"""
        return _ArNetworkingPy.ArServerClient_hasSlowPackets(self)


    def hasIdlePackets(self):
        """hasIdlePackets(ArServerClient self) -> bool"""
        return _ArNetworkingPy.ArServerClient_hasIdlePackets(self)


    def startRequestTransaction(self):
        """startRequestTransaction(ArServerClient self)"""
        return _ArNetworkingPy.ArServerClient_startRequestTransaction(self)


    def endRequestTransaction(self):
        """endRequestTransaction(ArServerClient self) -> bool"""
        return _ArNetworkingPy.ArServerClient_endRequestTransaction(self)


    def getRequestTransactionCount(self):
        """getRequestTransactionCount(ArServerClient self) -> int"""
        return _ArNetworkingPy.ArServerClient_getRequestTransactionCount(self)


    def findCommandFromName(self, commandName):
        """findCommandFromName(ArServerClient self, char const * commandName) -> unsigned int"""
        return _ArNetworkingPy.ArServerClient_findCommandFromName(self, commandName)


    def getCreationTime(self):
        """getCreationTime(ArServerClient self) -> ArTime"""
        return _ArNetworkingPy.ArServerClient_getCreationTime(self)


    def findCommandName(self, command):
        """findCommandName(ArServerClient self, unsigned int command) -> char const *"""
        return _ArNetworkingPy.ArServerClient_findCommandName(self, command)

ArServerClient_swigregister = _ArNetworkingPy.ArServerClient_swigregister
ArServerClient_swigregister(ArServerClient)

class ArServerClientIdentifier(_object):
    """Proxy of C++ ArServerClientIdentifier class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerClientIdentifier, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerClientIdentifier, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ArServerClientIdentifier self) -> ArServerClientIdentifier"""
        this = _ArNetworkingPy.new_ArServerClientIdentifier()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerClientIdentifier
    __del__ = lambda self: None

    def getIDString(self):
        """getIDString(ArServerClientIdentifier self) -> char const *"""
        return _ArNetworkingPy.ArServerClientIdentifier_getIDString(self)


    def setConnectionID(self, idNum):
        """setConnectionID(ArServerClientIdentifier self, ArTypes::UByte4 idNum)"""
        return _ArNetworkingPy.ArServerClientIdentifier_setConnectionID(self, idNum)


    def getConnectionID(self):
        """getConnectionID(ArServerClientIdentifier self) -> ArTypes::UByte4"""
        return _ArNetworkingPy.ArServerClientIdentifier_getConnectionID(self)


    def setSelfIdentifier(self, selfIdentifier):
        """setSelfIdentifier(ArServerClientIdentifier self, char const * selfIdentifier)"""
        return _ArNetworkingPy.ArServerClientIdentifier_setSelfIdentifier(self, selfIdentifier)


    def getSelfIdentifier(self):
        """getSelfIdentifier(ArServerClientIdentifier self) -> char const *"""
        return _ArNetworkingPy.ArServerClientIdentifier_getSelfIdentifier(self)


    def setHereGoal(self, selfIdentifier):
        """setHereGoal(ArServerClientIdentifier self, char const * selfIdentifier)"""
        return _ArNetworkingPy.ArServerClientIdentifier_setHereGoal(self, selfIdentifier)


    def getHereGoal(self):
        """getHereGoal(ArServerClientIdentifier self) -> char const *"""
        return _ArNetworkingPy.ArServerClientIdentifier_getHereGoal(self)


    def matches(self, identifier, matchConnectionID):
        """matches(ArServerClientIdentifier self, ArServerClientIdentifier identifier, bool matchConnectionID) -> bool"""
        return _ArNetworkingPy.ArServerClientIdentifier_matches(self, identifier, matchConnectionID)


    def rebuildIDString(self):
        """rebuildIDString(ArServerClientIdentifier self)"""
        return _ArNetworkingPy.ArServerClientIdentifier_rebuildIDString(self)

ArServerClientIdentifier_swigregister = _ArNetworkingPy.ArServerClientIdentifier_swigregister
ArServerClientIdentifier_swigregister(ArServerClientIdentifier)

class ArServerClientData(_object):
    """Proxy of C++ ArServerClientData class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerClientData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerClientData, name)
    __repr__ = _swig_repr

    def __init__(self, serverData, mSecInterval, packet):
        """__init__(ArServerClientData self, ArServerData * serverData, long mSecInterval, ArNetPacket packet) -> ArServerClientData"""
        this = _ArNetworkingPy.new_ArServerClientData(serverData, mSecInterval, packet)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerClientData
    __del__ = lambda self: None

    def getServerData(self):
        """getServerData(ArServerClientData self) -> ArServerData *"""
        return _ArNetworkingPy.ArServerClientData_getServerData(self)


    def getMSec(self):
        """getMSec(ArServerClientData self) -> long"""
        return _ArNetworkingPy.ArServerClientData_getMSec(self)


    def getPacket(self):
        """getPacket(ArServerClientData self) -> ArNetPacket"""
        return _ArNetworkingPy.ArServerClientData_getPacket(self)


    def getLastSent(self):
        """getLastSent(ArServerClientData self) -> ArTime"""
        return _ArNetworkingPy.ArServerClientData_getLastSent(self)


    def setLastSentToNow(self):
        """setLastSentToNow(ArServerClientData self)"""
        return _ArNetworkingPy.ArServerClientData_setLastSentToNow(self)


    def setMSec(self, mSec):
        """setMSec(ArServerClientData self, long mSec)"""
        return _ArNetworkingPy.ArServerClientData_setMSec(self, mSec)


    def setPacket(self, packet):
        """setPacket(ArServerClientData self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerClientData_setPacket(self, packet)

ArServerClientData_swigregister = _ArNetworkingPy.ArServerClientData_swigregister
ArServerClientData_swigregister(ArServerClientData)

class ArServerCommands(_object):
    """Proxy of C++ ArServerCommands class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerCommands, name)
    __repr__ = _swig_repr
    SHUTDOWN = _ArNetworkingPy.ArServerCommands_SHUTDOWN
    INTRODUCTION = _ArNetworkingPy.ArServerCommands_INTRODUCTION
    UDP_INTRODUCTION = _ArNetworkingPy.ArServerCommands_UDP_INTRODUCTION
    UDP_CONFIRMATION = _ArNetworkingPy.ArServerCommands_UDP_CONFIRMATION
    CONNECTED = _ArNetworkingPy.ArServerCommands_CONNECTED
    REJECTED = _ArNetworkingPy.ArServerCommands_REJECTED
    TCP_ONLY = _ArNetworkingPy.ArServerCommands_TCP_ONLY
    LIST = _ArNetworkingPy.ArServerCommands_LIST
    LISTSINGLE = _ArNetworkingPy.ArServerCommands_LISTSINGLE
    LISTARGRET = _ArNetworkingPy.ArServerCommands_LISTARGRET
    LISTARGRETSINGLE = _ArNetworkingPy.ArServerCommands_LISTARGRETSINGLE
    LISTGROUPANDFLAGS = _ArNetworkingPy.ArServerCommands_LISTGROUPANDFLAGS
    LISTGROUPANDFLAGSSINGLE = _ArNetworkingPy.ArServerCommands_LISTGROUPANDFLAGSSINGLE
    TYPE_UNSPECIFIED = _ArNetworkingPy.ArServerCommands_TYPE_UNSPECIFIED
    TYPE_REAL = _ArNetworkingPy.ArServerCommands_TYPE_REAL
    TYPE_SIMULATED = _ArNetworkingPy.ArServerCommands_TYPE_SIMULATED
    TYPE_NONE = _ArNetworkingPy.ArServerCommands_TYPE_NONE

    def toString(type):
        """toString(ArServerCommands::Type type) -> char const *"""
        return _ArNetworkingPy.ArServerCommands_toString(type)

    if _newclass:
        toString = staticmethod(toString)
    __swig_getmethods__["toString"] = lambda x: toString

    def __init__(self):
        """__init__(ArServerCommands self) -> ArServerCommands"""
        this = _ArNetworkingPy.new_ArServerCommands()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerCommands
    __del__ = lambda self: None
ArServerCommands_swigregister = _ArNetworkingPy.ArServerCommands_swigregister
ArServerCommands_swigregister(ArServerCommands)

def ArServerCommands_toString(type):
    """ArServerCommands_toString(ArServerCommands::Type type) -> char const *"""
    return _ArNetworkingPy.ArServerCommands_toString(type)

class ArServerFileLister(_object):
    """Proxy of C++ ArServerFileLister class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerFileLister, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerFileLister, name)
    __repr__ = _swig_repr

    def __init__(self, server, topDir, defaultUploadDownloadDir=None):
        """
        __init__(ArServerFileLister self, ArServerBase server, char const * topDir, char const * defaultUploadDownloadDir=None) -> ArServerFileLister
        __init__(ArServerFileLister self, ArServerBase server, char const * topDir) -> ArServerFileLister
        """
        this = _ArNetworkingPy.new_ArServerFileLister(server, topDir, defaultUploadDownloadDir)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerFileLister
    __del__ = lambda self: None

    def getDirListing(self, client, packet):
        """getDirListing(ArServerFileLister self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileLister_getDirListing(self, client, packet)


    def getDirListingMultiplePackets(self, client, packet):
        """getDirListingMultiplePackets(ArServerFileLister self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileLister_getDirListingMultiplePackets(self, client, packet)


    def getDefaultUploadDownloadDir(self, client, packet):
        """getDefaultUploadDownloadDir(ArServerFileLister self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileLister_getDefaultUploadDownloadDir(self, client, packet)

ArServerFileLister_swigregister = _ArNetworkingPy.ArServerFileLister_swigregister
ArServerFileLister_swigregister(ArServerFileLister)

class ArServerFileToClient(_object):
    """Proxy of C++ ArServerFileToClient class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerFileToClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerFileToClient, name)
    __repr__ = _swig_repr

    def __init__(self, server, topDir):
        """__init__(ArServerFileToClient self, ArServerBase server, char const * topDir) -> ArServerFileToClient"""
        this = _ArNetworkingPy.new_ArServerFileToClient(server, topDir)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerFileToClient
    __del__ = lambda self: None

    def getFile(self, client, packet):
        """getFile(ArServerFileToClient self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileToClient_getFile(self, client, packet)


    def getFileWithTimestamp(self, client, packet):
        """getFileWithTimestamp(ArServerFileToClient self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileToClient_getFileWithTimestamp(self, client, packet)

ArServerFileToClient_swigregister = _ArNetworkingPy.ArServerFileToClient_swigregister
ArServerFileToClient_swigregister(ArServerFileToClient)

class ArServerFileFromClient(_object):
    """Proxy of C++ ArServerFileFromClient class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerFileFromClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerFileFromClient, name)
    __repr__ = _swig_repr

    def __init__(self, server, topDir, tempDir):
        """__init__(ArServerFileFromClient self, ArServerBase server, char const * topDir, char const * tempDir) -> ArServerFileFromClient"""
        this = _ArNetworkingPy.new_ArServerFileFromClient(server, topDir, tempDir)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerFileFromClient
    __del__ = lambda self: None

    def putFile(self, client, packet):
        """putFile(ArServerFileFromClient self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFile(self, client, packet)


    def putFileInterleaved(self, client, packet):
        """putFileInterleaved(ArServerFileFromClient self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFileInterleaved(self, client, packet)


    def putFileWithTimestamp(self, client, packet):
        """putFileWithTimestamp(ArServerFileFromClient self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFileWithTimestamp(self, client, packet)


    def putFileWithTimestampInterleaved(self, client, packet):
        """putFileWithTimestampInterleaved(ArServerFileFromClient self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFileWithTimestampInterleaved(self, client, packet)


    def addPreMoveCallback(self, *args):
        """
        addPreMoveCallback(ArServerFileFromClient self, ArFunctor functor, ArListPos::Pos position)
        addPreMoveCallback(ArServerFileFromClient self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerFileFromClient_addPreMoveCallback(self, *args)


    def remPreMoveCallback(self, functor):
        """remPreMoveCallback(ArServerFileFromClient self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerFileFromClient_remPreMoveCallback(self, functor)


    def addPostMoveCallback(self, *args):
        """
        addPostMoveCallback(ArServerFileFromClient self, ArFunctor functor, ArListPos::Pos position)
        addPostMoveCallback(ArServerFileFromClient self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerFileFromClient_addPostMoveCallback(self, *args)


    def remPostMoveCallback(self, functor):
        """remPostMoveCallback(ArServerFileFromClient self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerFileFromClient_remPostMoveCallback(self, functor)


    def getMovingFileName(self):
        """getMovingFileName(ArServerFileFromClient self) -> char const *"""
        return _ArNetworkingPy.ArServerFileFromClient_getMovingFileName(self)

ArServerFileFromClient_swigregister = _ArNetworkingPy.ArServerFileFromClient_swigregister
ArServerFileFromClient_swigregister(ArServerFileFromClient)

class ArServerDeleteFileOnServer(_object):
    """Proxy of C++ ArServerDeleteFileOnServer class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerDeleteFileOnServer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerDeleteFileOnServer, name)
    __repr__ = _swig_repr

    def __init__(self, server, topDir):
        """__init__(ArServerDeleteFileOnServer self, ArServerBase server, char const * topDir) -> ArServerDeleteFileOnServer"""
        this = _ArNetworkingPy.new_ArServerDeleteFileOnServer(server, topDir)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerDeleteFileOnServer
    __del__ = lambda self: None

    def deleteFile(self, client, packet):
        """deleteFile(ArServerDeleteFileOnServer self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_deleteFile(self, client, packet)


    def addPreDeleteCallback(self, *args):
        """
        addPreDeleteCallback(ArServerDeleteFileOnServer self, ArFunctor functor, ArListPos::Pos position)
        addPreDeleteCallback(ArServerDeleteFileOnServer self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerDeleteFileOnServer_addPreDeleteCallback(self, *args)


    def remPreDeleteCallback(self, functor):
        """remPreDeleteCallback(ArServerDeleteFileOnServer self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_remPreDeleteCallback(self, functor)


    def addPostDeleteCallback(self, *args):
        """
        addPostDeleteCallback(ArServerDeleteFileOnServer self, ArFunctor functor, ArListPos::Pos position)
        addPostDeleteCallback(ArServerDeleteFileOnServer self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerDeleteFileOnServer_addPostDeleteCallback(self, *args)


    def remPostDeleteCallback(self, functor):
        """remPostDeleteCallback(ArServerDeleteFileOnServer self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_remPostDeleteCallback(self, functor)


    def getDeletingFileName(self):
        """getDeletingFileName(ArServerDeleteFileOnServer self) -> char const *"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_getDeletingFileName(self)

ArServerDeleteFileOnServer_swigregister = _ArNetworkingPy.ArServerDeleteFileOnServer_swigregister
ArServerDeleteFileOnServer_swigregister(ArServerDeleteFileOnServer)

class ArServerHandlerCamera(AriaPy.ArCameraCollectionItem):
    """Proxy of C++ ArServerHandlerCamera class."""

    __swig_setmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCamera, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCamera, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArServerHandlerCamera self, char const * cameraName, ArServerBase server, ArRobot robot, ArPTZ camera, ArCameraCollection collection) -> ArServerHandlerCamera
        __init__(ArServerHandlerCamera self, ArServerBase server, ArRobot robot, ArPTZ camera) -> ArServerHandlerCamera
        """
        this = _ArNetworkingPy.new_ArServerHandlerCamera(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCamera
    __del__ = lambda self: None

    def setCameraAbs(self, pan, tilt, zoom, lockRobot=True):
        """
        setCameraAbs(ArServerHandlerCamera self, double pan, double tilt, double zoom, bool lockRobot=True)
        setCameraAbs(ArServerHandlerCamera self, double pan, double tilt, double zoom)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_setCameraAbs(self, pan, tilt, zoom, lockRobot)


    def setCameraRel(self, pan, tilt, zoom, lockRobot=True):
        """
        setCameraRel(ArServerHandlerCamera self, double pan, double tilt, double zoom, bool lockRobot=True)
        setCameraRel(ArServerHandlerCamera self, double pan, double tilt, double zoom)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_setCameraRel(self, pan, tilt, zoom, lockRobot)


    def setCameraPct(self, panPct, tiltPct, lockRobot=True):
        """
        setCameraPct(ArServerHandlerCamera self, double panPct, double tiltPct, bool lockRobot=True)
        setCameraPct(ArServerHandlerCamera self, double panPct, double tiltPct)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_setCameraPct(self, panPct, tiltPct, lockRobot)


    def resetCamera(self, lockRobot=True):
        """
        resetCamera(ArServerHandlerCamera self, bool lockRobot=True)
        resetCamera(ArServerHandlerCamera self)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_resetCamera(self, lockRobot)


    def cameraModeLookAtGoal(self):
        """cameraModeLookAtGoal(ArServerHandlerCamera self)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtGoal(self)


    def cameraModeLookAtPoint(self, pose, controlZoom=True):
        """
        cameraModeLookAtPoint(ArServerHandlerCamera self, ArPose pose, bool controlZoom=True)
        cameraModeLookAtPoint(ArServerHandlerCamera self, ArPose pose)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtPoint(self, pose, controlZoom)


    def cameraModeLookAtGoalSetGoal(self, pose):
        """cameraModeLookAtGoalSetGoal(ArServerHandlerCamera self, ArPose pose)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtGoalSetGoal(self, pose)


    def cameraModeLookAtGoalClearGoal(self):
        """cameraModeLookAtGoalClearGoal(ArServerHandlerCamera self)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtGoalClearGoal(self)


    def cameraModePosition(self):
        """cameraModePosition(ArServerHandlerCamera self)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModePosition(self)


    def getCameraName(self):
        """getCameraName(ArServerHandlerCamera self) -> char const *"""
        return _ArNetworkingPy.ArServerHandlerCamera_getCameraName(self)


    def addToCameraCollection(self, collection):
        """addToCameraCollection(ArServerHandlerCamera self, ArCameraCollection collection)"""
        return _ArNetworkingPy.ArServerHandlerCamera_addToCameraCollection(self, collection)


    def handleGetCameraData(self, client, packet):
        """handleGetCameraData(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleGetCameraData(self, client, packet)


    def handleGetCameraInfo(self, client, packet):
        """handleGetCameraInfo(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleGetCameraInfo(self, client, packet)


    def handleSetCameraAbs(self, client, packet):
        """handleSetCameraAbs(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraAbs(self, client, packet)


    def handleSetCameraPct(self, client, packet):
        """handleSetCameraPct(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraPct(self, client, packet)


    def handleSetCameraRel(self, client, packet):
        """handleSetCameraRel(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraRel(self, client, packet)


    def handleGetCameraModeList(self, client, packet):
        """handleGetCameraModeList(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleGetCameraModeList(self, client, packet)


    def handleCameraModeUpdated(self, client, packet):
        """handleCameraModeUpdated(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleCameraModeUpdated(self, client, packet)


    def handleSetCameraMode(self, client, packet):
        """handleSetCameraMode(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraMode(self, client, packet)


    def handleResetCamera(self, client, packet):
        """handleResetCamera(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleResetCamera(self, client, packet)


    def camera(self, client, packet):
        """camera(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_camera(self, client, packet)


    def cameraAbs(self, client, packet):
        """cameraAbs(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraAbs(self, client, packet)


    def cameraPct(self, client, packet):
        """cameraPct(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraPct(self, client, packet)


    def cameraUpdate(self, client, packet):
        """cameraUpdate(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraUpdate(self, client, packet)


    def cameraInfo(self, client, packet):
        """cameraInfo(ArServerHandlerCamera self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraInfo(self, client, packet)

ArServerHandlerCamera_swigregister = _ArNetworkingPy.ArServerHandlerCamera_swigregister
ArServerHandlerCamera_swigregister(ArServerHandlerCamera)

class ArServerHandlerCameraCollection(_object):
    """Proxy of C++ ArServerHandlerCameraCollection class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCameraCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCameraCollection, name)
    __repr__ = _swig_repr

    def __init__(self, server, cameraCollection):
        """__init__(ArServerHandlerCameraCollection self, ArServerBase server, ArCameraCollection cameraCollection) -> ArServerHandlerCameraCollection"""
        this = _ArNetworkingPy.new_ArServerHandlerCameraCollection(server, cameraCollection)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCameraCollection
    __del__ = lambda self: None

    def getCameraList(self, client, packet):
        """getCameraList(ArServerHandlerCameraCollection self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCameraCollection_getCameraList(self, client, packet)


    def setParams(self, client, packet):
        """setParams(ArServerHandlerCameraCollection self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCameraCollection_setParams(self, client, packet)


    def handleCameraCollectionModified(self):
        """handleCameraCollectionModified(ArServerHandlerCameraCollection self)"""
        return _ArNetworkingPy.ArServerHandlerCameraCollection_handleCameraCollectionModified(self)

ArServerHandlerCameraCollection_swigregister = _ArNetworkingPy.ArServerHandlerCameraCollection_swigregister
ArServerHandlerCameraCollection_swigregister(ArServerHandlerCameraCollection)

class ArServerHandlerCommMonitor(_object):
    """Proxy of C++ ArServerHandlerCommMonitor class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCommMonitor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCommMonitor, name)
    __repr__ = _swig_repr
    MIN_HEARTBEAT_INTERVAL = _ArNetworkingPy.ArServerHandlerCommMonitor_MIN_HEARTBEAT_INTERVAL
    DEFAULT_HEARTBEAT_INTERVAL = _ArNetworkingPy.ArServerHandlerCommMonitor_DEFAULT_HEARTBEAT_INTERVAL

    def __init__(self, *args):
        """
        __init__(ArServerHandlerCommMonitor self, ArServerBase server, int heartbeatInterval) -> ArServerHandlerCommMonitor
        __init__(ArServerHandlerCommMonitor self, ArServerBase server) -> ArServerHandlerCommMonitor
        """
        this = _ArNetworkingPy.new_ArServerHandlerCommMonitor(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCommMonitor
    __del__ = lambda self: None

    def handleGetHeartbeatInterval(self, client, packet):
        """handleGetHeartbeatInterval(ArServerHandlerCommMonitor self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_handleGetHeartbeatInterval(self, client, packet)


    def handleAckCommTcp(self, client, packet):
        """handleAckCommTcp(ArServerHandlerCommMonitor self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_handleAckCommTcp(self, client, packet)


    def handleAckCommUdp(self, client, packet):
        """handleAckCommUdp(ArServerHandlerCommMonitor self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_handleAckCommUdp(self, client, packet)


    def cycleCallback(self):
        """cycleCallback(ArServerHandlerCommMonitor self)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_cycleCallback(self)

ArServerHandlerCommMonitor_swigregister = _ArNetworkingPy.ArServerHandlerCommMonitor_swigregister
ArServerHandlerCommMonitor_swigregister(ArServerHandlerCommMonitor)

class ArServerHandlerCommands(_object):
    """Proxy of C++ ArServerHandlerCommands class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCommands, name)
    __repr__ = _swig_repr

    def __init__(self, server):
        """__init__(ArServerHandlerCommands self, ArServerBase server) -> ArServerHandlerCommands"""
        this = _ArNetworkingPy.new_ArServerHandlerCommands(server)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCommands
    __del__ = lambda self: None

    def setTextServer(self, textServer):
        """setTextServer(ArServerHandlerCommands self, ArNetServer textServer)"""
        return _ArNetworkingPy.ArServerHandlerCommands_setTextServer(self, textServer)


    def addCommand(self, name, description, functor, commandGroup=None):
        """
        addCommand(ArServerHandlerCommands self, char const * name, char const * description, ArFunctor functor, char const * commandGroup=None) -> bool
        addCommand(ArServerHandlerCommands self, char const * name, char const * description, ArFunctor functor) -> bool
        """
        return _ArNetworkingPy.ArServerHandlerCommands_addCommand(self, name, description, functor, commandGroup)


    def addStringCommand(self, name, description, functor, commandGroup=None):
        """
        addStringCommand(ArServerHandlerCommands self, char const * name, char const * description, ArFunctor1< ArArgumentBuilder * > * functor, char const * commandGroup=None) -> bool
        addStringCommand(ArServerHandlerCommands self, char const * name, char const * description, ArFunctor1< ArArgumentBuilder * > * functor) -> bool
        """
        return _ArNetworkingPy.ArServerHandlerCommands_addStringCommand(self, name, description, functor, commandGroup)


    def setPrefix(self, prefix):
        """setPrefix(ArServerHandlerCommands self, char const * prefix)"""
        return _ArNetworkingPy.ArServerHandlerCommands_setPrefix(self, prefix)


    def getPrefix(self):
        """getPrefix(ArServerHandlerCommands self) -> char const *"""
        return _ArNetworkingPy.ArServerHandlerCommands_getPrefix(self)


    def netListCommands(self, client, packet):
        """netListCommands(ArServerHandlerCommands self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommands_netListCommands(self, client, packet)


    def netListStringCommands(self, client, packet):
        """netListStringCommands(ArServerHandlerCommands self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommands_netListStringCommands(self, client, packet)

ArServerHandlerCommands_swigregister = _ArNetworkingPy.ArServerHandlerCommands_swigregister
ArServerHandlerCommands_swigregister(ArServerHandlerCommands)

class ArServerHandlerConfig(_object):
    """Proxy of C++ ArServerHandlerConfig class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerConfig, name)
    __repr__ = _swig_repr

    def __init__(self, server, config, defaultFile=None, defaultFileBaseDirectory=None, allowFactory=True, robotName=None, preventChanges=False, preventChangesString=None):
        """
        __init__(ArServerHandlerConfig self, ArServerBase server, ArConfig config, char const * defaultFile=None, char const * defaultFileBaseDirectory=None, bool allowFactory=True, char const * robotName=None, bool preventChanges=False, char const * preventChangesString=None) -> ArServerHandlerConfig
        __init__(ArServerHandlerConfig self, ArServerBase server, ArConfig config, char const * defaultFile=None, char const * defaultFileBaseDirectory=None, bool allowFactory=True, char const * robotName=None, bool preventChanges=False) -> ArServerHandlerConfig
        __init__(ArServerHandlerConfig self, ArServerBase server, ArConfig config, char const * defaultFile=None, char const * defaultFileBaseDirectory=None, bool allowFactory=True, char const * robotName=None) -> ArServerHandlerConfig
        __init__(ArServerHandlerConfig self, ArServerBase server, ArConfig config, char const * defaultFile=None, char const * defaultFileBaseDirectory=None, bool allowFactory=True) -> ArServerHandlerConfig
        __init__(ArServerHandlerConfig self, ArServerBase server, ArConfig config, char const * defaultFile=None, char const * defaultFileBaseDirectory=None) -> ArServerHandlerConfig
        __init__(ArServerHandlerConfig self, ArServerBase server, ArConfig config, char const * defaultFile=None) -> ArServerHandlerConfig
        __init__(ArServerHandlerConfig self, ArServerBase server, ArConfig config) -> ArServerHandlerConfig
        """
        this = _ArNetworkingPy.new_ArServerHandlerConfig(server, config, defaultFile, defaultFileBaseDirectory, allowFactory, robotName, preventChanges, preventChangesString)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerConfig
    __del__ = lambda self: None

    def reloadConfig(self, client, packet):
        """reloadConfig(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_reloadConfig(self, client, packet)


    def getConfigBySections(self, client, packet):
        """getConfigBySections(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigBySections(self, client, packet)


    def getConfigBySectionsV2(self, client, packet):
        """getConfigBySectionsV2(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigBySectionsV2(self, client, packet)


    def getConfigBySectionsV3(self, client, packet):
        """getConfigBySectionsV3(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigBySectionsV3(self, client, packet)


    def getConfigBySectionsV4(self, client, packet):
        """getConfigBySectionsV4(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigBySectionsV4(self, client, packet)


    def getConfig(self, client, packet):
        """getConfig(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfig(self, client, packet)


    def setConfig(self, client, packet):
        """setConfig(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setConfig(self, client, packet)


    def setConfigParam(self, client, packet):
        """setConfigParam(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setConfigParam(self, client, packet)


    def setConfigBySections(self, client, packet):
        """setConfigBySections(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setConfigBySections(self, client, packet)


    def setConfigBySectionsV2(self, client, packet):
        """setConfigBySectionsV2(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setConfigBySectionsV2(self, client, packet)


    def getConfigDefaults(self, client, packet):
        """getConfigDefaults(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigDefaults(self, client, packet)


    def getConfigSectionFlags(self, client, packet):
        """getConfigSectionFlags(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigSectionFlags(self, client, packet)


    def getLastEditablePriority(self, client, packet):
        """getLastEditablePriority(ArServerHandlerConfig self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getLastEditablePriority(self, client, packet)


    def addPreWriteCallback(self, *args):
        """
        addPreWriteCallback(ArServerHandlerConfig self, ArFunctor functor, ArListPos::Pos position)
        addPreWriteCallback(ArServerHandlerConfig self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addPreWriteCallback(self, *args)


    def remPreWriteCallback(self, functor):
        """remPreWriteCallback(ArServerHandlerConfig self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remPreWriteCallback(self, functor)


    def addPostWriteCallback(self, *args):
        """
        addPostWriteCallback(ArServerHandlerConfig self, ArFunctor functor, ArListPos::Pos position)
        addPostWriteCallback(ArServerHandlerConfig self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addPostWriteCallback(self, *args)


    def remPostWriteCallback(self, functor):
        """remPostWriteCallback(ArServerHandlerConfig self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remPostWriteCallback(self, functor)


    def addConfigUpdatedCallback(self, *args):
        """
        addConfigUpdatedCallback(ArServerHandlerConfig self, ArFunctor functor, ArListPos::Pos position)
        addConfigUpdatedCallback(ArServerHandlerConfig self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addConfigUpdatedCallback(self, *args)


    def remConfigUpdatedCallback(self, functor):
        """remConfigUpdatedCallback(ArServerHandlerConfig self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remConfigUpdatedCallback(self, functor)


    def restartIO(self, reason):
        """restartIO(ArServerHandlerConfig self, char const * reason)"""
        return _ArNetworkingPy.ArServerHandlerConfig_restartIO(self, reason)


    def restartSoftware(self, reason):
        """restartSoftware(ArServerHandlerConfig self, char const * reason)"""
        return _ArNetworkingPy.ArServerHandlerConfig_restartSoftware(self, reason)


    def restartHardware(self, reason):
        """restartHardware(ArServerHandlerConfig self, char const * reason)"""
        return _ArNetworkingPy.ArServerHandlerConfig_restartHardware(self, reason)


    def addRestartIOCB(self, functor, position=50):
        """
        addRestartIOCB(ArServerHandlerConfig self, ArFunctor functor, int position=50)
        addRestartIOCB(ArServerHandlerConfig self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addRestartIOCB(self, functor, position)


    def remRestartIOCB(self, functor):
        """remRestartIOCB(ArServerHandlerConfig self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remRestartIOCB(self, functor)


    def setRestartSoftwareCB(self, restartServerCB):
        """setRestartSoftwareCB(ArServerHandlerConfig self, ArFunctor restartServerCB)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setRestartSoftwareCB(self, restartServerCB)


    def getRestartSoftwareCB(self):
        """getRestartSoftwareCB(ArServerHandlerConfig self) -> ArFunctor"""
        return _ArNetworkingPy.ArServerHandlerConfig_getRestartSoftwareCB(self)


    def setRestartHardwareCB(self, restartRobotCB):
        """setRestartHardwareCB(ArServerHandlerConfig self, ArFunctor restartRobotCB)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setRestartHardwareCB(self, restartRobotCB)


    def getRestartHardwareCB(self):
        """getRestartHardwareCB(ArServerHandlerConfig self) -> ArFunctor"""
        return _ArNetworkingPy.ArServerHandlerConfig_getRestartHardwareCB(self)


    def lockConfig(self):
        """lockConfig(ArServerHandlerConfig self) -> int"""
        return _ArNetworkingPy.ArServerHandlerConfig_lockConfig(self)


    def tryLockConfig(self):
        """tryLockConfig(ArServerHandlerConfig self) -> int"""
        return _ArNetworkingPy.ArServerHandlerConfig_tryLockConfig(self)


    def unlockConfig(self):
        """unlockConfig(ArServerHandlerConfig self) -> int"""
        return _ArNetworkingPy.ArServerHandlerConfig_unlockConfig(self)


    def writeConfig(self):
        """writeConfig(ArServerHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_writeConfig(self)


    def configUpdated(self, client=None):
        """
        configUpdated(ArServerHandlerConfig self, ArServerClient client=None) -> bool
        configUpdated(ArServerHandlerConfig self) -> bool
        """
        return _ArNetworkingPy.ArServerHandlerConfig_configUpdated(self, client)


    def setPreventChanges(self, preventChanges=False, preventChangesString=None):
        """
        setPreventChanges(ArServerHandlerConfig self, bool preventChanges=False, char const * preventChangesString=None)
        setPreventChanges(ArServerHandlerConfig self, bool preventChanges=False)
        setPreventChanges(ArServerHandlerConfig self)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_setPreventChanges(self, preventChanges, preventChangesString)


    def loadDefaultsFromFile(self):
        """loadDefaultsFromFile(ArServerHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_loadDefaultsFromFile(self)


    def loadDefaultsFromPacket(self, packet):
        """loadDefaultsFromPacket(ArServerHandlerConfig self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_loadDefaultsFromPacket(self, packet)


    def createEmptyConfigDefaults(self):
        """createEmptyConfigDefaults(ArServerHandlerConfig self)"""
        return _ArNetworkingPy.ArServerHandlerConfig_createEmptyConfigDefaults(self)


    def setAllowFactory(self, allowFactory):
        """setAllowFactory(ArServerHandlerConfig self, bool allowFactory)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setAllowFactory(self, allowFactory)


    def getAllowFactory(self):
        """getAllowFactory(ArServerHandlerConfig self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_getAllowFactory(self)

ArServerHandlerConfig_swigregister = _ArNetworkingPy.ArServerHandlerConfig_swigregister
ArServerHandlerConfig_swigregister(ArServerHandlerConfig)

class ArServerHandlerMap(_object):
    """Proxy of C++ ArServerHandlerMap class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerMap, name)
    __repr__ = _swig_repr
    LINES = _ArNetworkingPy.ArServerHandlerMap_LINES
    POINTS = _ArNetworkingPy.ArServerHandlerMap_POINTS
    BOTH = _ArNetworkingPy.ArServerHandlerMap_BOTH

    def __init__(self, *args):
        """
        __init__(ArServerHandlerMap self, ArServerBase server, ArMapInterface arMap=None, ArServerHandlerMap::DataToSend dataToSend) -> ArServerHandlerMap
        __init__(ArServerHandlerMap self, ArServerBase server, ArMapInterface arMap=None) -> ArServerHandlerMap
        __init__(ArServerHandlerMap self, ArServerBase server) -> ArServerHandlerMap
        """
        this = _ArNetworkingPy.new_ArServerHandlerMap(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerMap
    __del__ = lambda self: None

    def loadMap(self, mapFile):
        """loadMap(ArServerHandlerMap self, char const * mapFile) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMap_loadMap(self, mapFile)


    def useMap(self, mapObj, takeOwnershipOfMap=False):
        """
        useMap(ArServerHandlerMap self, ArMapInterface mapObj, bool takeOwnershipOfMap=False)
        useMap(ArServerHandlerMap self, ArMapInterface mapObj)
        """
        return _ArNetworkingPy.ArServerHandlerMap_useMap(self, mapObj, takeOwnershipOfMap)


    def getMap(self):
        """getMap(ArServerHandlerMap self) -> ArMapInterface"""
        return _ArNetworkingPy.ArServerHandlerMap_getMap(self)


    def serverGetMapId(self, client, packet):
        """serverGetMapId(ArServerHandlerMap self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapId(self, client, packet)


    def serverGetMapName(self, client, packet):
        """serverGetMapName(ArServerHandlerMap self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapName(self, client, packet)


    def serverGetMap(self, client, packet):
        """serverGetMap(ArServerHandlerMap self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMap(self, client, packet)


    def serverGetMapBinary(self, client, packet):
        """serverGetMapBinary(ArServerHandlerMap self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapBinary(self, client, packet)


    def serverGetMapMultiScans(self, client, packet):
        """serverGetMapMultiScans(ArServerHandlerMap self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapMultiScans(self, client, packet)


    def serverGetMapWithMaxCategory(self, client, packet):
        """serverGetMapWithMaxCategory(ArServerHandlerMap self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapWithMaxCategory(self, client, packet)


    def serverGetGoals(self, client, packet):
        """serverGetGoals(ArServerHandlerMap self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetGoals(self, client, packet)


    def setDataToSend(self, dataToSend):
        """setDataToSend(ArServerHandlerMap self, ArServerHandlerMap::DataToSend dataToSend)"""
        return _ArNetworkingPy.ArServerHandlerMap_setDataToSend(self, dataToSend)


    def getDataToSend(self):
        """getDataToSend(ArServerHandlerMap self) -> ArServerHandlerMap::DataToSend"""
        return _ArNetworkingPy.ArServerHandlerMap_getDataToSend(self)

ArServerHandlerMap_swigregister = _ArNetworkingPy.ArServerHandlerMap_swigregister
ArServerHandlerMap_swigregister(ArServerHandlerMap)

class ArServerHandlerMapping(_object):
    """Proxy of C++ ArServerHandlerMapping class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerMapping, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerMapping, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArServerHandlerMapping self, ArServerBase server, ArRobot robot, ArLaser laser, char const * baseDirectory, char const * tempDirectory, bool useReflectorValues=False, ArLaser laser2=None, char const * sickSuffix=None, char const * sick2Suffix=None, std::list< ArLaser *,std::allocator< ArLaser * > > * extraLasers=None) -> ArServerHandlerMapping
        __init__(ArServerHandlerMapping self, ArServerBase server, ArRobot robot, ArLaser laser, char const * baseDirectory, char const * tempDirectory, bool useReflectorValues=False, ArLaser laser2=None, char const * sickSuffix=None, char const * sick2Suffix=None) -> ArServerHandlerMapping
        __init__(ArServerHandlerMapping self, ArServerBase server, ArRobot robot, ArLaser laser, char const * baseDirectory, char const * tempDirectory, bool useReflectorValues=False, ArLaser laser2=None, char const * sickSuffix=None) -> ArServerHandlerMapping
        __init__(ArServerHandlerMapping self, ArServerBase server, ArRobot robot, ArLaser laser, char const * baseDirectory, char const * tempDirectory, bool useReflectorValues=False, ArLaser laser2=None) -> ArServerHandlerMapping
        __init__(ArServerHandlerMapping self, ArServerBase server, ArRobot robot, ArLaser laser, char const * baseDirectory, char const * tempDirectory, bool useReflectorValues=False) -> ArServerHandlerMapping
        __init__(ArServerHandlerMapping self, ArServerBase server, ArRobot robot, ArLaser laser, char const * baseDirectory, char const * tempDirectory) -> ArServerHandlerMapping
        __init__(ArServerHandlerMapping self, ArServerBase server, ArRobot robot, ArLaser laser, char const * baseDirectory) -> ArServerHandlerMapping
        __init__(ArServerHandlerMapping self, ArServerBase server, ArRobot robot, ArLaser laser) -> ArServerHandlerMapping
        """
        this = _ArNetworkingPy.new_ArServerHandlerMapping(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerMapping
    __del__ = lambda self: None

    def serverMappingStart(self, client, packet):
        """serverMappingStart(ArServerHandlerMapping self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMapping_serverMappingStart(self, client, packet)


    def serverMappingEnd(self, client, packet):
        """serverMappingEnd(ArServerHandlerMapping self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMapping_serverMappingEnd(self, client, packet)


    def serverMappingStatus(self, client, packet):
        """serverMappingStatus(ArServerHandlerMapping self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMapping_serverMappingStatus(self, client, packet)


    def isMapping(self):
        """isMapping(ArServerHandlerMapping self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMapping_isMapping(self)


    def forceReading(self):
        """forceReading(ArServerHandlerMapping self)"""
        return _ArNetworkingPy.ArServerHandlerMapping_forceReading(self)


    def getFileName(self):
        """getFileName(ArServerHandlerMapping self) -> char const *"""
        return _ArNetworkingPy.ArServerHandlerMapping_getFileName(self)


    def getMapName(self):
        """getMapName(ArServerHandlerMapping self) -> char const *"""
        return _ArNetworkingPy.ArServerHandlerMapping_getMapName(self)


    def addSimpleCommands(self, handlerCommands):
        """addSimpleCommands(ArServerHandlerMapping self, ArServerHandlerCommands handlerCommands)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addSimpleCommands(self, handlerCommands)


    def simpleLoopStart(self, arg):
        """simpleLoopStart(ArServerHandlerMapping self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerHandlerMapping_simpleLoopStart(self, arg)


    def simpleLoopEnd(self, arg):
        """simpleLoopEnd(ArServerHandlerMapping self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerHandlerMapping_simpleLoopEnd(self, arg)


    def addStringForStartOfLogs(self, *args):
        """
        addStringForStartOfLogs(ArServerHandlerMapping self, char const * str, ArListPos::Pos position)
        addStringForStartOfLogs(ArServerHandlerMapping self, char const * str)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addStringForStartOfLogs(self, *args)


    def remStringForStartOfLogs(self, str):
        """remStringForStartOfLogs(ArServerHandlerMapping self, char const * str)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remStringForStartOfLogs(self, str)


    def addTagToLog(self, str):
        """addTagToLog(ArServerHandlerMapping self, char const * str)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addTagToLog(self, str)


    def addInfoToLog(self, str):
        """addInfoToLog(ArServerHandlerMapping self, char const * str)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addInfoToLog(self, str)


    def addLocationData(self, name, functor):
        """addLocationData(ArServerHandlerMapping self, char const * name, ArRetFunctor3< int,ArTime,ArPose *,ArPoseWithTime * > * functor) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMapping_addLocationData(self, name, functor)


    def addMappingStartCallback(self, *args):
        """
        addMappingStartCallback(ArServerHandlerMapping self, ArFunctor functor, ArListPos::Pos position)
        addMappingStartCallback(ArServerHandlerMapping self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addMappingStartCallback(self, *args)


    def remMappingStartCallback(self, functor):
        """remMappingStartCallback(ArServerHandlerMapping self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remMappingStartCallback(self, functor)


    def addMappingBegunCallback(self, *args):
        """
        addMappingBegunCallback(ArServerHandlerMapping self, ArFunctor functor, ArListPos::Pos position)
        addMappingBegunCallback(ArServerHandlerMapping self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addMappingBegunCallback(self, *args)


    def remMappingBegunCallback(self, functor):
        """remMappingBegunCallback(ArServerHandlerMapping self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remMappingBegunCallback(self, functor)


    def addMappingEndCallback(self, *args):
        """
        addMappingEndCallback(ArServerHandlerMapping self, ArFunctor functor, ArListPos::Pos position)
        addMappingEndCallback(ArServerHandlerMapping self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addMappingEndCallback(self, *args)


    def remMappingEndCallback(self, functor):
        """remMappingEndCallback(ArServerHandlerMapping self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remMappingEndCallback(self, functor)


    def addMappingEndedCallback(self, *args):
        """
        addMappingEndedCallback(ArServerHandlerMapping self, ArFunctor functor, ArListPos::Pos position)
        addMappingEndedCallback(ArServerHandlerMapping self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addMappingEndedCallback(self, *args)


    def remMappingEndedCallback(self, functor):
        """remMappingEndedCallback(ArServerHandlerMapping self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remMappingEndedCallback(self, functor)


    def addPreMoveCallback(self, *args):
        """
        addPreMoveCallback(ArServerHandlerMapping self, ArFunctor functor, ArListPos::Pos position)
        addPreMoveCallback(ArServerHandlerMapping self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addPreMoveCallback(self, *args)


    def remPreMoveCallback(self, functor):
        """remPreMoveCallback(ArServerHandlerMapping self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remPreMoveCallback(self, functor)


    def addPostMoveCallback(self, *args):
        """
        addPostMoveCallback(ArServerHandlerMapping self, ArFunctor functor, ArListPos::Pos position)
        addPostMoveCallback(ArServerHandlerMapping self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addPostMoveCallback(self, *args)


    def remPostMoveCallback(self, functor):
        """remPostMoveCallback(ArServerHandlerMapping self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remPostMoveCallback(self, functor)


    def packetHandler(self, packet):
        """packetHandler(ArServerHandlerMapping self, ArRobotPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMapping_packetHandler(self, packet)


    def getLocationDataMap(self):
        """getLocationDataMap(ArServerHandlerMapping self) -> std::map< std::string,ArRetFunctor3< int,ArTime,ArPose *,ArPoseWithTime * > *,ArStrCaseCmpOp,std::allocator< std::pair< std::string const,ArRetFunctor3< int,ArTime,ArPose *,ArPoseWithTime * > * > > > const *"""
        return _ArNetworkingPy.ArServerHandlerMapping_getLocationDataMap(self)


    def addStringsForStartOfLogToMap(self, arMap):
        """addStringsForStartOfLogToMap(ArServerHandlerMapping self, ArMap arMap)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addStringsForStartOfLogToMap(self, arMap)


    def getZipFile(self):
        """getZipFile(ArServerHandlerMapping self) -> ArZippable *"""
        return _ArNetworkingPy.ArServerHandlerMapping_getZipFile(self)


    def getSnapshotZipFile(self):
        """getSnapshotZipFile(ArServerHandlerMapping self) -> ArZippable *"""
        return _ArNetworkingPy.ArServerHandlerMapping_getSnapshotZipFile(self)


    def setZipFile(self, zipFile):
        """setZipFile(ArServerHandlerMapping self, ArZippable * zipFile)"""
        return _ArNetworkingPy.ArServerHandlerMapping_setZipFile(self, zipFile)


    def setSnapshotZipFile(self, zipFile):
        """setSnapshotZipFile(ArServerHandlerMapping self, ArZippable * zipFile)"""
        return _ArNetworkingPy.ArServerHandlerMapping_setSnapshotZipFile(self, zipFile)

ArServerHandlerMapping_swigregister = _ArNetworkingPy.ArServerHandlerMapping_swigregister
ArServerHandlerMapping_swigregister(ArServerHandlerMapping)

class ArServerInfoDrawings(_object):
    """Proxy of C++ ArServerInfoDrawings class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoDrawings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoDrawings, name)
    __repr__ = _swig_repr

    def __init__(self, server):
        """__init__(ArServerInfoDrawings self, ArServerBase server) -> ArServerInfoDrawings"""
        this = _ArNetworkingPy.new_ArServerInfoDrawings(server)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoDrawings
    __del__ = lambda self: None

    def addDrawing(self, drawingData, name, functor):
        """addDrawing(ArServerInfoDrawings self, ArDrawingData drawingData, char const * name, ArFunctor2< ArServerClient *,ArNetPacket * > * functor) -> bool"""
        return _ArNetworkingPy.ArServerInfoDrawings_addDrawing(self, drawingData, name, functor)


    def addRangeDevice(self, rangeDevice):
        """addRangeDevice(ArServerInfoDrawings self, ArRangeDevice rangeDevice) -> bool"""
        return _ArNetworkingPy.ArServerInfoDrawings_addRangeDevice(self, rangeDevice)


    def addRobotsRangeDevices(self, robot):
        """addRobotsRangeDevices(ArServerInfoDrawings self, ArRobot robot) -> bool"""
        return _ArNetworkingPy.ArServerInfoDrawings_addRobotsRangeDevices(self, robot)


    def netListDrawings(self, client, packet):
        """netListDrawings(ArServerInfoDrawings self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netListDrawings(self, client, packet)


    def netGetDrawingList(self, client, packet):
        """netGetDrawingList(ArServerInfoDrawings self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netGetDrawingList(self, client, packet)


    def netRangeDeviceCurrent(self, client, packet, device):
        """netRangeDeviceCurrent(ArServerInfoDrawings self, ArServerClient client, ArNetPacket packet, ArRangeDevice device)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netRangeDeviceCurrent(self, client, packet, device)


    def netRangeDeviceCumulative(self, client, packet, device):
        """netRangeDeviceCumulative(ArServerInfoDrawings self, ArServerClient client, ArNetPacket packet, ArRangeDevice device)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netRangeDeviceCumulative(self, client, packet, device)


    def internalGetDrawingData(self, name):
        """internalGetDrawingData(ArServerInfoDrawings self, char const * name) -> ArDrawingData"""
        return _ArNetworkingPy.ArServerInfoDrawings_internalGetDrawingData(self, name)


    def internalGetDrawingCallback(self, name):
        """internalGetDrawingCallback(ArServerInfoDrawings self, char const * name) -> ArFunctor2< ArServerClient *,ArNetPacket * > *"""
        return _ArNetworkingPy.ArServerInfoDrawings_internalGetDrawingCallback(self, name)

ArServerInfoDrawings_swigregister = _ArNetworkingPy.ArServerInfoDrawings_swigregister
ArServerInfoDrawings_swigregister(ArServerInfoDrawings)

class ArServerInfoRobot(_object):
    """Proxy of C++ ArServerInfoRobot class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoRobot, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoRobot, name)
    __repr__ = _swig_repr

    def __init__(self, server, robot):
        """__init__(ArServerInfoRobot self, ArServerBase server, ArRobot robot) -> ArServerInfoRobot"""
        this = _ArNetworkingPy.new_ArServerInfoRobot(server, robot)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoRobot
    __del__ = lambda self: None

    def update(self, client, packet):
        """update(ArServerInfoRobot self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_update(self, client, packet)


    def updateNumbers(self, client, packet):
        """updateNumbers(ArServerInfoRobot self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_updateNumbers(self, client, packet)


    def updateStrings(self, client, packet):
        """updateStrings(ArServerInfoRobot self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_updateStrings(self, client, packet)


    def batteryInfo(self, client, packet):
        """batteryInfo(ArServerInfoRobot self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_batteryInfo(self, client, packet)


    def physicalInfo(self, client, packet):
        """physicalInfo(ArServerInfoRobot self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_physicalInfo(self, client, packet)


    def activityTimeInfo(self, client, packet):
        """activityTimeInfo(ArServerInfoRobot self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_activityTimeInfo(self, client, packet)

ArServerInfoRobot_swigregister = _ArNetworkingPy.ArServerInfoRobot_swigregister
ArServerInfoRobot_swigregister(ArServerInfoRobot)

class ArServerInfoSensor(_object):
    """Proxy of C++ ArServerInfoSensor class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoSensor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoSensor, name)
    __repr__ = _swig_repr

    def __init__(self, server, robot):
        """__init__(ArServerInfoSensor self, ArServerBase server, ArRobot robot) -> ArServerInfoSensor"""
        this = _ArNetworkingPy.new_ArServerInfoSensor(server, robot)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoSensor
    __del__ = lambda self: None

    def getSensorList(self, client, packet):
        """getSensorList(ArServerInfoSensor self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoSensor_getSensorList(self, client, packet)


    def getSensorCurrent(self, client, packet):
        """getSensorCurrent(ArServerInfoSensor self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoSensor_getSensorCurrent(self, client, packet)


    def getSensorCumulative(self, client, packet):
        """getSensorCumulative(ArServerInfoSensor self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoSensor_getSensorCumulative(self, client, packet)

ArServerInfoSensor_swigregister = _ArNetworkingPy.ArServerInfoSensor_swigregister
ArServerInfoSensor_swigregister(ArServerInfoSensor)

class ArServerInfoStrings(_object):
    """Proxy of C++ ArServerInfoStrings class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoStrings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoStrings, name)
    __repr__ = _swig_repr

    def __init__(self, server):
        """__init__(ArServerInfoStrings self, ArServerBase server) -> ArServerInfoStrings"""
        this = _ArNetworkingPy.new_ArServerInfoStrings(server)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoStrings
    __del__ = lambda self: None

    def netGetStringsInfo(self, client, packet):
        """netGetStringsInfo(ArServerInfoStrings self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoStrings_netGetStringsInfo(self, client, packet)


    def netGetStrings(self, client, packet):
        """netGetStrings(ArServerInfoStrings self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoStrings_netGetStrings(self, client, packet)


    def addString(self, name, maxLen, functor):
        """addString(ArServerInfoStrings self, char const * name, ArTypes::UByte2 maxLen, ArFunctor2< char *,ArTypes::UByte2 > * functor)"""
        return _ArNetworkingPy.ArServerInfoStrings_addString(self, name, maxLen, functor)


    def getAddStringFunctor(self):
        """getAddStringFunctor(ArServerInfoStrings self) -> ArFunctor3< char const *,ArTypes::UByte2,ArFunctor2< char *,ArTypes::UByte2 > * > *"""
        return _ArNetworkingPy.ArServerInfoStrings_getAddStringFunctor(self)


    def internalGetStringInfoHolder(self, name):
        """internalGetStringInfoHolder(ArServerInfoStrings self, char const * name) -> ArStringInfoHolder"""
        return _ArNetworkingPy.ArServerInfoStrings_internalGetStringInfoHolder(self, name)

ArServerInfoStrings_swigregister = _ArNetworkingPy.ArServerInfoStrings_swigregister
ArServerInfoStrings_swigregister(ArServerInfoStrings)

class ArServerModeDrive(ArServerMode):
    """Proxy of C++ ArServerModeDrive class."""

    __swig_setmethods__ = {}
    for _s in [ArServerMode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeDrive, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeDrive, name)
    __repr__ = _swig_repr

    def __init__(self, server, robot, takeControlOnJoystick=False):
        """
        __init__(ArServerModeDrive self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=False) -> ArServerModeDrive
        __init__(ArServerModeDrive self, ArServerBase server, ArRobot robot) -> ArServerModeDrive
        """
        this = _ArNetworkingPy.new_ArServerModeDrive(server, robot, takeControlOnJoystick)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeDrive
    __del__ = lambda self: None

    def activate(self):
        """activate(ArServerModeDrive self)"""
        return _ArNetworkingPy.ArServerModeDrive_activate(self)


    def deactivate(self):
        """deactivate(ArServerModeDrive self)"""
        return _ArNetworkingPy.ArServerModeDrive_deactivate(self)


    def addControlCommands(self, handlerCommands):
        """addControlCommands(ArServerModeDrive self, ArServerHandlerCommands handlerCommands)"""
        return _ArNetworkingPy.ArServerModeDrive_addControlCommands(self, handlerCommands)


    def driveJoystick(self, vel, rotVel, isActivating=True):
        """
        driveJoystick(ArServerModeDrive self, double vel, double rotVel, bool isActivating=True)
        driveJoystick(ArServerModeDrive self, double vel, double rotVel)
        """
        return _ArNetworkingPy.ArServerModeDrive_driveJoystick(self, vel, rotVel, isActivating)


    def serverDriveJoystick(self, client, packet):
        """serverDriveJoystick(ArServerModeDrive self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerModeDrive_serverDriveJoystick(self, client, packet)


    def userTask(self):
        """userTask(ArServerModeDrive self)"""
        return _ArNetworkingPy.ArServerModeDrive_userTask(self)


    def setThrottleParams(self, lowSpeed, highSpeed):
        """setThrottleParams(ArServerModeDrive self, int lowSpeed, int highSpeed)"""
        return _ArNetworkingPy.ArServerModeDrive_setThrottleParams(self, lowSpeed, highSpeed)


    def getActionGroup(self):
        """getActionGroup(ArServerModeDrive self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeDrive_getActionGroup(self)


    def setSafeDriving(self, safe):
        """setSafeDriving(ArServerModeDrive self, bool safe)"""
        return _ArNetworkingPy.ArServerModeDrive_setSafeDriving(self, safe)


    def getSafeDriving(self):
        """getSafeDriving(ArServerModeDrive self) -> bool"""
        return _ArNetworkingPy.ArServerModeDrive_getSafeDriving(self)


    def setExtraUnsafeAction(self, action):
        """setExtraUnsafeAction(ArServerModeDrive self, ArAction action)"""
        return _ArNetworkingPy.ArServerModeDrive_setExtraUnsafeAction(self, action)

ArServerModeDrive_swigregister = _ArNetworkingPy.ArServerModeDrive_swigregister
ArServerModeDrive_swigregister(ArServerModeDrive)

class ArServerModeIdle(ArServerMode):
    """Proxy of C++ ArServerModeIdle class."""

    __swig_setmethods__ = {}
    for _s in [ArServerMode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeIdle, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeIdle, name)
    __repr__ = _swig_repr

    def __init__(self, server, robot):
        """__init__(ArServerModeIdle self, ArServerBase server, ArRobot robot) -> ArServerModeIdle"""
        this = _ArNetworkingPy.new_ArServerModeIdle(server, robot)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeIdle
    __del__ = lambda self: None

    def activate(self):
        """activate(ArServerModeIdle self)"""
        return _ArNetworkingPy.ArServerModeIdle_activate(self)


    def deactivate(self):
        """deactivate(ArServerModeIdle self)"""
        return _ArNetworkingPy.ArServerModeIdle_deactivate(self)


    def userTask(self):
        """userTask(ArServerModeIdle self)"""
        return _ArNetworkingPy.ArServerModeIdle_userTask(self)


    def setModeInterrupted(self, modeInterrupted):
        """setModeInterrupted(ArServerModeIdle self, ArServerMode modeInterrupted)"""
        return _ArNetworkingPy.ArServerModeIdle_setModeInterrupted(self, modeInterrupted)


    def getModeInterrupted(self):
        """getModeInterrupted(ArServerModeIdle self) -> ArServerMode"""
        return _ArNetworkingPy.ArServerModeIdle_getModeInterrupted(self)


    def getActionGroup(self):
        """getActionGroup(ArServerModeIdle self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeIdle_getActionGroup(self)


    def addToConfig(self, *args):
        """
        addToConfig(ArServerModeIdle self, ArConfig config, char const * section)
        addToConfig(ArServerModeIdle self, ArConfig config)
        """
        return _ArNetworkingPy.ArServerModeIdle_addToConfig(self, *args)


    def setUseLocationDependentDevices(self, useLocationDependentDevices, internal=False):
        """
        setUseLocationDependentDevices(ArServerModeIdle self, bool useLocationDependentDevices, bool internal=False)
        setUseLocationDependentDevices(ArServerModeIdle self, bool useLocationDependentDevices)
        """
        return _ArNetworkingPy.ArServerModeIdle_setUseLocationDependentDevices(self, useLocationDependentDevices, internal)


    def getUseLocationDependentDevices(self):
        """getUseLocationDependentDevices(ArServerModeIdle self) -> bool"""
        return _ArNetworkingPy.ArServerModeIdle_getUseLocationDependentDevices(self)

ArServerModeIdle_swigregister = _ArNetworkingPy.ArServerModeIdle_swigregister
ArServerModeIdle_swigregister(ArServerModeIdle)

class ArServerModeRatioDrive(ArServerMode):
    """Proxy of C++ ArServerModeRatioDrive class."""

    __swig_setmethods__ = {}
    for _s in [ArServerMode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeRatioDrive, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeRatioDrive, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArServerModeRatioDrive self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True, bool useComputerJoystick=True, bool useRobotJoystick=True, bool useServerCommands=True, char const * name, bool robotJoystickOverridesLocks=True) -> ArServerModeRatioDrive
        __init__(ArServerModeRatioDrive self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True, bool useComputerJoystick=True, bool useRobotJoystick=True, bool useServerCommands=True, char const * name) -> ArServerModeRatioDrive
        __init__(ArServerModeRatioDrive self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True, bool useComputerJoystick=True, bool useRobotJoystick=True, bool useServerCommands=True) -> ArServerModeRatioDrive
        __init__(ArServerModeRatioDrive self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True, bool useComputerJoystick=True, bool useRobotJoystick=True) -> ArServerModeRatioDrive
        __init__(ArServerModeRatioDrive self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True, bool useComputerJoystick=True) -> ArServerModeRatioDrive
        __init__(ArServerModeRatioDrive self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True) -> ArServerModeRatioDrive
        __init__(ArServerModeRatioDrive self, ArServerBase server, ArRobot robot) -> ArServerModeRatioDrive
        """
        this = _ArNetworkingPy.new_ArServerModeRatioDrive(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeRatioDrive
    __del__ = lambda self: None

    def activate(self):
        """activate(ArServerModeRatioDrive self)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_activate(self)


    def deactivate(self):
        """deactivate(ArServerModeRatioDrive self)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_deactivate(self)


    def addControlCommands(self, handlerCommands):
        """addControlCommands(ArServerModeRatioDrive self, ArServerHandlerCommands handlerCommands)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_addControlCommands(self, handlerCommands)


    def ratioDrive(self, transRatio, rotRatio, throttleRatio, isActivating=False, latRatio=0):
        """
        ratioDrive(ArServerModeRatioDrive self, double transRatio, double rotRatio, double throttleRatio, bool isActivating=False, double latRatio=0)
        ratioDrive(ArServerModeRatioDrive self, double transRatio, double rotRatio, double throttleRatio, bool isActivating=False)
        ratioDrive(ArServerModeRatioDrive self, double transRatio, double rotRatio, double throttleRatio)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_ratioDrive(self, transRatio, rotRatio, throttleRatio, isActivating, latRatio)


    def addToConfig(self, config, section):
        """addToConfig(ArServerModeRatioDrive self, ArConfig config, char const * section)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_addToConfig(self, config, section)


    def userTask(self):
        """userTask(ArServerModeRatioDrive self)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_userTask(self)


    def getActionGroup(self):
        """getActionGroup(ArServerModeRatioDrive self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getActionGroup(self)


    def getActionRatioInput(self):
        """getActionRatioInput(ArServerModeRatioDrive self) -> ArActionRatioInput"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getActionRatioInput(self)


    def setSafeDriving(self, safe, internal=False):
        """
        setSafeDriving(ArServerModeRatioDrive self, bool safe, bool internal=False)
        setSafeDriving(ArServerModeRatioDrive self, bool safe)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_setSafeDriving(self, safe, internal)


    def getSafeDriving(self):
        """getSafeDriving(ArServerModeRatioDrive self) -> bool"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getSafeDriving(self)


    def setUseLocationDependentDevices(self, useLocationDependentDevices, internal=False):
        """
        setUseLocationDependentDevices(ArServerModeRatioDrive self, bool useLocationDependentDevices, bool internal=False)
        setUseLocationDependentDevices(ArServerModeRatioDrive self, bool useLocationDependentDevices)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_setUseLocationDependentDevices(self, useLocationDependentDevices, internal)


    def getUseLocationDependentDevices(self):
        """getUseLocationDependentDevices(ArServerModeRatioDrive self) -> bool"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getUseLocationDependentDevices(self)


    def addSafeDrivingCallback(self, functor, position=50):
        """
        addSafeDrivingCallback(ArServerModeRatioDrive self, ArFunctor functor, int position=50)
        addSafeDrivingCallback(ArServerModeRatioDrive self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_addSafeDrivingCallback(self, functor, position)


    def remSafeDrivingCallback(self, functor):
        """remSafeDrivingCallback(ArServerModeRatioDrive self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_remSafeDrivingCallback(self, functor)


    def addUnsafeDrivingCallback(self, functor, position=50):
        """
        addUnsafeDrivingCallback(ArServerModeRatioDrive self, ArFunctor functor, int position=50)
        addUnsafeDrivingCallback(ArServerModeRatioDrive self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_addUnsafeDrivingCallback(self, functor, position)


    def remUnsafeDrivingCallback(self, functor):
        """remUnsafeDrivingCallback(ArServerModeRatioDrive self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_remUnsafeDrivingCallback(self, functor)


    def addDrivingBackwardsCallback(self, functor, position=50):
        """
        addDrivingBackwardsCallback(ArServerModeRatioDrive self, ArFunctor functor, int position=50)
        addDrivingBackwardsCallback(ArServerModeRatioDrive self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_addDrivingBackwardsCallback(self, functor, position)


    def remDrivingBackwardsCallback(self, functor):
        """remDrivingBackwardsCallback(ArServerModeRatioDrive self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_remDrivingBackwardsCallback(self, functor)

ArServerModeRatioDrive_swigregister = _ArNetworkingPy.ArServerModeRatioDrive_swigregister
ArServerModeRatioDrive_swigregister(ArServerModeRatioDrive)

class ArServerModeStop(ArServerMode):
    """Proxy of C++ ArServerModeStop class."""

    __swig_setmethods__ = {}
    for _s in [ArServerMode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeStop, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeStop, name)
    __repr__ = _swig_repr

    def __init__(self, server, robot, defunct=False):
        """
        __init__(ArServerModeStop self, ArServerBase server, ArRobot robot, bool defunct=False) -> ArServerModeStop
        __init__(ArServerModeStop self, ArServerBase server, ArRobot robot) -> ArServerModeStop
        """
        this = _ArNetworkingPy.new_ArServerModeStop(server, robot, defunct)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeStop
    __del__ = lambda self: None

    def activate(self):
        """activate(ArServerModeStop self)"""
        return _ArNetworkingPy.ArServerModeStop_activate(self)


    def deactivate(self):
        """deactivate(ArServerModeStop self)"""
        return _ArNetworkingPy.ArServerModeStop_deactivate(self)


    def stop(self):
        """stop(ArServerModeStop self)"""
        return _ArNetworkingPy.ArServerModeStop_stop(self)


    def netStop(self, client, packet):
        """netStop(ArServerModeStop self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerModeStop_netStop(self, client, packet)


    def userTask(self):
        """userTask(ArServerModeStop self)"""
        return _ArNetworkingPy.ArServerModeStop_userTask(self)


    def checkDefault(self):
        """checkDefault(ArServerModeStop self)"""
        return _ArNetworkingPy.ArServerModeStop_checkDefault(self)


    def getActionGroup(self):
        """getActionGroup(ArServerModeStop self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeStop_getActionGroup(self)


    def addToConfig(self, *args):
        """
        addToConfig(ArServerModeStop self, ArConfig config, char const * section)
        addToConfig(ArServerModeStop self, ArConfig config)
        """
        return _ArNetworkingPy.ArServerModeStop_addToConfig(self, *args)


    def setUseLocationDependentDevices(self, useLocationDependentDevices, internal=False):
        """
        setUseLocationDependentDevices(ArServerModeStop self, bool useLocationDependentDevices, bool internal=False)
        setUseLocationDependentDevices(ArServerModeStop self, bool useLocationDependentDevices)
        """
        return _ArNetworkingPy.ArServerModeStop_setUseLocationDependentDevices(self, useLocationDependentDevices, internal)


    def getUseLocationDependentDevices(self):
        """getUseLocationDependentDevices(ArServerModeStop self) -> bool"""
        return _ArNetworkingPy.ArServerModeStop_getUseLocationDependentDevices(self)

ArServerModeStop_swigregister = _ArNetworkingPy.ArServerModeStop_swigregister
ArServerModeStop_swigregister(ArServerModeStop)

class ArServerModeWander(ArServerMode):
    """Proxy of C++ ArServerModeWander class."""

    __swig_setmethods__ = {}
    for _s in [ArServerMode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeWander, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeWander, name)
    __repr__ = _swig_repr

    def __init__(self, server, robot):
        """__init__(ArServerModeWander self, ArServerBase server, ArRobot robot) -> ArServerModeWander"""
        this = _ArNetworkingPy.new_ArServerModeWander(server, robot)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeWander
    __del__ = lambda self: None

    def activate(self):
        """activate(ArServerModeWander self)"""
        return _ArNetworkingPy.ArServerModeWander_activate(self)


    def deactivate(self):
        """deactivate(ArServerModeWander self)"""
        return _ArNetworkingPy.ArServerModeWander_deactivate(self)


    def wander(self):
        """wander(ArServerModeWander self)"""
        return _ArNetworkingPy.ArServerModeWander_wander(self)


    def netWander(self, client, packet):
        """netWander(ArServerModeWander self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerModeWander_netWander(self, client, packet)


    def userTask(self):
        """userTask(ArServerModeWander self)"""
        return _ArNetworkingPy.ArServerModeWander_userTask(self)


    def checkDefault(self):
        """checkDefault(ArServerModeWander self)"""
        return _ArNetworkingPy.ArServerModeWander_checkDefault(self)


    def getActionGroup(self):
        """getActionGroup(ArServerModeWander self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeWander_getActionGroup(self)

ArServerModeWander_swigregister = _ArNetworkingPy.ArServerModeWander_swigregister
ArServerModeWander_swigregister(ArServerModeWander)

class ArServerSimpleComUC(_object):
    """Proxy of C++ ArServerSimpleComUC class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComUC, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComUC, name)
    __repr__ = _swig_repr

    def __init__(self, handlerCommands, robot):
        """__init__(ArServerSimpleComUC self, ArServerHandlerCommands handlerCommands, ArRobot robot) -> ArServerSimpleComUC"""
        this = _ArNetworkingPy.new_ArServerSimpleComUC(handlerCommands, robot)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComUC
    __del__ = lambda self: None

    def command(self, arg):
        """command(ArServerSimpleComUC self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerSimpleComUC_command(self, arg)


    def motionCommand(self, arg):
        """motionCommand(ArServerSimpleComUC self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerSimpleComUC_motionCommand(self, arg)

ArServerSimpleComUC_swigregister = _ArNetworkingPy.ArServerSimpleComUC_swigregister
ArServerSimpleComUC_swigregister(ArServerSimpleComUC)

class ArServerSimpleComMovementLogging(_object):
    """Proxy of C++ ArServerSimpleComMovementLogging class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComMovementLogging, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComMovementLogging, name)
    __repr__ = _swig_repr

    def __init__(self, handlerCommands, robot, popupHandler=None):
        """
        __init__(ArServerSimpleComMovementLogging self, ArServerHandlerCommands handlerCommands, ArRobot robot, ArServerHandlerPopup * popupHandler=None) -> ArServerSimpleComMovementLogging
        __init__(ArServerSimpleComMovementLogging self, ArServerHandlerCommands handlerCommands, ArRobot robot) -> ArServerSimpleComMovementLogging
        """
        this = _ArNetworkingPy.new_ArServerSimpleComMovementLogging(handlerCommands, robot, popupHandler)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComMovementLogging
    __del__ = lambda self: None

    def logMovementSentEnable(self):
        """logMovementSentEnable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementSentEnable(self)


    def logMovementSentDisable(self):
        """logMovementSentDisable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementSentDisable(self)


    def logMovementReceivedEnable(self):
        """logMovementReceivedEnable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementReceivedEnable(self)


    def logMovementReceivedDisable(self):
        """logMovementReceivedDisable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementReceivedDisable(self)


    def logVelocitiesReceivedEnable(self):
        """logVelocitiesReceivedEnable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logVelocitiesReceivedEnable(self)


    def logVelocitiesReceivedDisable(self):
        """logVelocitiesReceivedDisable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logVelocitiesReceivedDisable(self)


    def packetsReceivedTrackingEnable(self):
        """packetsReceivedTrackingEnable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsReceivedTrackingEnable(self)


    def packetsReceivedTrackingDisable(self):
        """packetsReceivedTrackingDisable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsReceivedTrackingDisable(self)


    def packetsSentTrackingEnable(self):
        """packetsSentTrackingEnable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsSentTrackingEnable(self)


    def packetsSentTrackingDisable(self):
        """packetsSentTrackingDisable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsSentTrackingDisable(self)


    def logActionsEnable(self):
        """logActionsEnable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logActionsEnable(self)


    def logActionsDisable(self):
        """logActionsDisable(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logActionsDisable(self)


    def logActions(self):
        """logActions(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logActions(self)


    def popupMovementParams(self):
        """popupMovementParams(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_popupMovementParams(self)


    def resetOdometer(self):
        """resetOdometer(ArServerSimpleComMovementLogging self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_resetOdometer(self)

ArServerSimpleComMovementLogging_swigregister = _ArNetworkingPy.ArServerSimpleComMovementLogging_swigregister
ArServerSimpleComMovementLogging_swigregister(ArServerSimpleComMovementLogging)

class ArServerSimpleComGyro(_object):
    """Proxy of C++ ArServerSimpleComGyro class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComGyro, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComGyro, name)
    __repr__ = _swig_repr

    def __init__(self, handlerCommands, robot, gyro):
        """__init__(ArServerSimpleComGyro self, ArServerHandlerCommands handlerCommands, ArRobot robot, ArAnalogGyro gyro) -> ArServerSimpleComGyro"""
        this = _ArNetworkingPy.new_ArServerSimpleComGyro(handlerCommands, robot, gyro)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComGyro
    __del__ = lambda self: None

    def gyroEnable(self):
        """gyroEnable(ArServerSimpleComGyro self)"""
        return _ArNetworkingPy.ArServerSimpleComGyro_gyroEnable(self)


    def gyroDisable(self):
        """gyroDisable(ArServerSimpleComGyro self)"""
        return _ArNetworkingPy.ArServerSimpleComGyro_gyroDisable(self)

ArServerSimpleComGyro_swigregister = _ArNetworkingPy.ArServerSimpleComGyro_swigregister
ArServerSimpleComGyro_swigregister(ArServerSimpleComGyro)

class ArServerSimpleComLogRobotConfig(_object):
    """Proxy of C++ ArServerSimpleComLogRobotConfig class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComLogRobotConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComLogRobotConfig, name)
    __repr__ = _swig_repr

    def __init__(self, commands, robot, popupHandler=None):
        """
        __init__(ArServerSimpleComLogRobotConfig self, ArServerHandlerCommands commands, ArRobot robot, ArServerHandlerPopup * popupHandler=None) -> ArServerSimpleComLogRobotConfig
        __init__(ArServerSimpleComLogRobotConfig self, ArServerHandlerCommands commands, ArRobot robot) -> ArServerSimpleComLogRobotConfig
        """
        this = _ArNetworkingPy.new_ArServerSimpleComLogRobotConfig(commands, robot, popupHandler)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def logConfig(self):
        """logConfig(ArServerSimpleComLogRobotConfig self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_logConfig(self)


    def logMovementConfig(self):
        """logMovementConfig(ArServerSimpleComLogRobotConfig self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_logMovementConfig(self)


    def logOrigConfig(self):
        """logOrigConfig(ArServerSimpleComLogRobotConfig self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_logOrigConfig(self)


    def popupConfig(self):
        """popupConfig(ArServerSimpleComLogRobotConfig self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_popupConfig(self)


    def popupOrigConfig(self):
        """popupOrigConfig(ArServerSimpleComLogRobotConfig self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_popupOrigConfig(self)


    def popupMovementConfig(self):
        """popupMovementConfig(ArServerSimpleComLogRobotConfig self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_popupMovementConfig(self)

    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComLogRobotConfig
    __del__ = lambda self: None
ArServerSimpleComLogRobotConfig_swigregister = _ArNetworkingPy.ArServerSimpleComLogRobotConfig_swigregister
ArServerSimpleComLogRobotConfig_swigregister(ArServerSimpleComLogRobotConfig)

class ArServerSimpleComLogActions(_object):
    """Proxy of C++ ArServerSimpleComLogActions class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComLogActions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComLogActions, name)
    __repr__ = _swig_repr

    def __init__(self, commands, robot):
        """__init__(ArServerSimpleComLogActions self, ArServerHandlerCommands commands, ArRobot robot) -> ArServerSimpleComLogActions"""
        this = _ArNetworkingPy.new_ArServerSimpleComLogActions(commands, robot)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def logActions(self):
        """logActions(ArServerSimpleComLogActions self)"""
        return _ArNetworkingPy.ArServerSimpleComLogActions_logActions(self)

    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComLogActions
    __del__ = lambda self: None
ArServerSimpleComLogActions_swigregister = _ArNetworkingPy.ArServerSimpleComLogActions_swigregister
ArServerSimpleComLogActions_swigregister(ArServerSimpleComLogActions)

class ArServerSimpleServerCommands(_object):
    """Proxy of C++ ArServerSimpleServerCommands class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleServerCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleServerCommands, name)
    __repr__ = _swig_repr

    def __init__(self, commands, server, addLogConnections=True):
        """
        __init__(ArServerSimpleServerCommands self, ArServerHandlerCommands commands, ArServerBase server, bool addLogConnections=True) -> ArServerSimpleServerCommands
        __init__(ArServerSimpleServerCommands self, ArServerHandlerCommands commands, ArServerBase server) -> ArServerSimpleServerCommands
        """
        this = _ArNetworkingPy.new_ArServerSimpleServerCommands(commands, server, addLogConnections)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleServerCommands
    __del__ = lambda self: None

    def logTerseTracking(self):
        """logTerseTracking(ArServerSimpleServerCommands self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_logTerseTracking(self)


    def logVerboseTracking(self):
        """logVerboseTracking(ArServerSimpleServerCommands self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_logVerboseTracking(self)


    def resetTracking(self):
        """resetTracking(ArServerSimpleServerCommands self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_resetTracking(self)


    def logConnections(self):
        """logConnections(ArServerSimpleServerCommands self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_logConnections(self)

ArServerSimpleServerCommands_swigregister = _ArNetworkingPy.ArServerSimpleServerCommands_swigregister
ArServerSimpleServerCommands_swigregister(ArServerSimpleServerCommands)

class ArServerSimplePopup(_object):
    """Proxy of C++ ArServerSimplePopup class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimplePopup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimplePopup, name)
    __repr__ = _swig_repr

    def __init__(self, commands, popupHandler):
        """__init__(ArServerSimplePopup self, ArServerHandlerCommands commands, ArServerHandlerPopup * popupHandler) -> ArServerSimplePopup"""
        this = _ArNetworkingPy.new_ArServerSimplePopup(commands, popupHandler)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimplePopup
    __del__ = lambda self: None

    def simplePopup(self, arg):
        """simplePopup(ArServerSimplePopup self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerSimplePopup_simplePopup(self, arg)

ArServerSimplePopup_swigregister = _ArNetworkingPy.ArServerSimplePopup_swigregister
ArServerSimplePopup_swigregister(ArServerSimplePopup)

class ArServerSimpleLogRobotDebugPackets(_object):
    """Proxy of C++ ArServerSimpleLogRobotDebugPackets class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleLogRobotDebugPackets, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleLogRobotDebugPackets, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArServerSimpleLogRobotDebugPackets self, ArServerHandlerCommands commands, ArRobot robot, char const * baseDirectory) -> ArServerSimpleLogRobotDebugPackets
        __init__(ArServerSimpleLogRobotDebugPackets self, ArServerHandlerCommands commands, ArRobot robot) -> ArServerSimpleLogRobotDebugPackets
        """
        this = _ArNetworkingPy.new_ArServerSimpleLogRobotDebugPackets(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleLogRobotDebugPackets
    __del__ = lambda self: None

    def startLogging(self, *args):
        """
        startLogging(ArServerSimpleLogRobotDebugPackets self, char const * fileName) -> bool
        startLogging(ArServerSimpleLogRobotDebugPackets self) -> bool
        """
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_startLogging(self, *args)


    def stopLogging(self):
        """stopLogging(ArServerSimpleLogRobotDebugPackets self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_stopLogging(self)


    def packetHandler(self, packet):
        """packetHandler(ArServerSimpleLogRobotDebugPackets self, ArRobotPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_packetHandler(self, packet)


    def addToInfoGroup(self, *args):
        """
        addToInfoGroup(ArServerSimpleLogRobotDebugPackets self, ArStringInfoGroup infoGroup, char const * name, int whichVal, char const * format)
        addToInfoGroup(ArServerSimpleLogRobotDebugPackets self, ArStringInfoGroup infoGroup, char const * name, int whichVal)
        """
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_addToInfoGroup(self, *args)


    def getNumValues(self):
        """getNumValues(ArServerSimpleLogRobotDebugPackets self) -> int"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_getNumValues(self)


    def getValue(self, whichVal):
        """getValue(ArServerSimpleLogRobotDebugPackets self, int whichVal) -> int"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_getValue(self, whichVal)

ArServerSimpleLogRobotDebugPackets_swigregister = _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_swigregister
ArServerSimpleLogRobotDebugPackets_swigregister(ArServerSimpleLogRobotDebugPackets)

class ArServerSimpleConnectionTester(_object):
    """Proxy of C++ ArServerSimpleConnectionTester class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleConnectionTester, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleConnectionTester, name)
    __repr__ = _swig_repr

    def __init__(self, handlerCommands, robot):
        """__init__(ArServerSimpleConnectionTester self, ArServerHandlerCommands handlerCommands, ArRobot robot) -> ArServerSimpleConnectionTester"""
        this = _ArNetworkingPy.new_ArServerSimpleConnectionTester(handlerCommands, robot)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleConnectionTester
    __del__ = lambda self: None

    def connectionTestStart(self):
        """connectionTestStart(ArServerSimpleConnectionTester self)"""
        return _ArNetworkingPy.ArServerSimpleConnectionTester_connectionTestStart(self)


    def connectionTestStop(self):
        """connectionTestStop(ArServerSimpleConnectionTester self)"""
        return _ArNetworkingPy.ArServerSimpleConnectionTester_connectionTestStop(self)

ArServerSimpleConnectionTester_swigregister = _ArNetworkingPy.ArServerSimpleConnectionTester_swigregister
ArServerSimpleConnectionTester_swigregister(ArServerSimpleConnectionTester)

class ArServerSimpleOpener(_object):
    """Proxy of C++ ArServerSimpleOpener class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleOpener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleOpener, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ArServerSimpleOpener self, ArArgumentParser parser, char const * prefix, bool addAriaCallbacks=True) -> ArServerSimpleOpener
        __init__(ArServerSimpleOpener self, ArArgumentParser parser, char const * prefix) -> ArServerSimpleOpener
        __init__(ArServerSimpleOpener self, ArArgumentParser parser) -> ArServerSimpleOpener
        """
        this = _ArNetworkingPy.new_ArServerSimpleOpener(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleOpener
    __del__ = lambda self: None

    def open(self, *args):
        """
        open(ArServerSimpleOpener self, ArServerBase server, char const * baseDirectory, int secondsToTryFor=240) -> bool
        open(ArServerSimpleOpener self, ArServerBase server, char const * baseDirectory) -> bool
        open(ArServerSimpleOpener self, ArServerBase server) -> bool
        """
        return _ArNetworkingPy.ArServerSimpleOpener_open(self, *args)


    def parseArgs(self, *args):
        """
        parseArgs(ArServerSimpleOpener self) -> bool
        parseArgs(ArServerSimpleOpener self, ArArgumentParser parser) -> bool
        """
        return _ArNetworkingPy.ArServerSimpleOpener_parseArgs(self, *args)


    def logOptions(self):
        """logOptions(ArServerSimpleOpener self)"""
        return _ArNetworkingPy.ArServerSimpleOpener_logOptions(self)


    def checkAndLog(self):
        """checkAndLog(ArServerSimpleOpener self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_checkAndLog(self)


    def wasUserFileBad(self):
        """wasUserFileBad(ArServerSimpleOpener self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_wasUserFileBad(self)


    def didOpenFail(self):
        """didOpenFail(ArServerSimpleOpener self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_didOpenFail(self)


    def getPort(self):
        """getPort(ArServerSimpleOpener self) -> int"""
        return _ArNetworkingPy.ArServerSimpleOpener_getPort(self)


    def setDefaultPort(self, port):
        """setDefaultPort(ArServerSimpleOpener self, int port)"""
        return _ArNetworkingPy.ArServerSimpleOpener_setDefaultPort(self, port)


    def parseFile(self, fileName):
        """parseFile(ArServerSimpleOpener self, char const * fileName) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_parseFile(self, fileName)


    def setServerTcpOnly(self, serverTcpOnly):
        """setServerTcpOnly(ArServerSimpleOpener self, bool serverTcpOnly)"""
        return _ArNetworkingPy.ArServerSimpleOpener_setServerTcpOnly(self, serverTcpOnly)


    def getServerKey(self):
        """getServerKey(ArServerSimpleOpener self) -> char const *"""
        return _ArNetworkingPy.ArServerSimpleOpener_getServerKey(self)

ArServerSimpleOpener_swigregister = _ArNetworkingPy.ArServerSimpleOpener_swigregister
ArServerSimpleOpener_swigregister(ArServerSimpleOpener)

class ArServerUserInfo(_object):
    """Proxy of C++ ArServerUserInfo class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerUserInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerUserInfo, name)
    __repr__ = _swig_repr

    def __init__(self, baseDirectory=None):
        """
        __init__(ArServerUserInfo self, char const * baseDirectory=None) -> ArServerUserInfo
        __init__(ArServerUserInfo self) -> ArServerUserInfo
        """
        this = _ArNetworkingPy.new_ArServerUserInfo(baseDirectory)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerUserInfo
    __del__ = lambda self: None

    def readFile(self, fileName):
        """readFile(ArServerUserInfo self, char const * fileName) -> bool"""
        return _ArNetworkingPy.ArServerUserInfo_readFile(self, fileName)


    def setBaseDirectory(self, baseDirectory):
        """setBaseDirectory(ArServerUserInfo self, char const * baseDirectory)"""
        return _ArNetworkingPy.ArServerUserInfo_setBaseDirectory(self, baseDirectory)


    def matchUserPassword(self, user, password, passwordKey, serverKey, logFailureVerbosely=False):
        """
        matchUserPassword(ArServerUserInfo self, char const * user, unsigned char [16] password, char const * passwordKey, char const * serverKey, bool logFailureVerbosely=False) -> bool
        matchUserPassword(ArServerUserInfo self, char const * user, unsigned char [16] password, char const * passwordKey, char const * serverKey) -> bool
        """
        return _ArNetworkingPy.ArServerUserInfo_matchUserPassword(self, user, password, passwordKey, serverKey, logFailureVerbosely)


    def doNotUse(self):
        """doNotUse(ArServerUserInfo self) -> bool"""
        return _ArNetworkingPy.ArServerUserInfo_doNotUse(self)


    def getUsersGroups(self, user):
        """getUsersGroups(ArServerUserInfo self, char const * user) -> std::set< std::string,ArStrCaseCmpOp,std::allocator< std::string > >"""
        return _ArNetworkingPy.ArServerUserInfo_getUsersGroups(self, user)


    def logUsers(self):
        """logUsers(ArServerUserInfo self)"""
        return _ArNetworkingPy.ArServerUserInfo_logUsers(self)

ArServerUserInfo_swigregister = _ArNetworkingPy.ArServerUserInfo_swigregister
ArServerUserInfo_swigregister(ArServerUserInfo)

class ArClientHandlerRobotUpdate(_object):
    """Proxy of C++ ArClientHandlerRobotUpdate class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientHandlerRobotUpdate, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientHandlerRobotUpdate, name)
    __repr__ = _swig_repr

    def __init__(self, client):
        """__init__(ArClientHandlerRobotUpdate self, ArClientBase client) -> ArClientHandlerRobotUpdate"""
        this = _ArNetworkingPy.new_ArClientHandlerRobotUpdate(client)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientHandlerRobotUpdate
    __del__ = lambda self: None

    def requestUpdates(self, freq=100):
        """
        requestUpdates(ArClientHandlerRobotUpdate self, int freq=100)
        requestUpdates(ArClientHandlerRobotUpdate self)
        """
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_requestUpdates(self, freq)


    def stopUpdates(self):
        """stopUpdates(ArClientHandlerRobotUpdate self)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_stopUpdates(self)


    def addStatusChangedCB(self, cb):
        """addStatusChangedCB(ArClientHandlerRobotUpdate self, ArFunctor2< char const *,char const * > * cb)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_addStatusChangedCB(self, cb)


    def remStatusChangedCB(self, cb):
        """remStatusChangedCB(ArClientHandlerRobotUpdate self, ArFunctor2< char const *,char const * > * cb)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_remStatusChangedCB(self, cb)


    def addModeChangedCB(self, cb):
        """addModeChangedCB(ArClientHandlerRobotUpdate self, ArFunctor1_CString cb)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_addModeChangedCB(self, cb)


    def remModeChangedCB(self, cb):
        """remModeChangedCB(ArClientHandlerRobotUpdate self, ArFunctor1_CString cb)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_remModeChangedCB(self, cb)


    def lock(self):
        """lock(ArClientHandlerRobotUpdate self)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_lock(self)


    def unlock(self):
        """unlock(ArClientHandlerRobotUpdate self)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_unlock(self)


    def getX(self):
        """getX(ArClientHandlerRobotUpdate self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getX(self)


    def getY(self):
        """getY(ArClientHandlerRobotUpdate self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getY(self)


    def getTh(self):
        """getTh(ArClientHandlerRobotUpdate self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getTh(self)


    def getPose(self):
        """getPose(ArClientHandlerRobotUpdate self) -> ArPose"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getPose(self)


    def getVel(self):
        """getVel(ArClientHandlerRobotUpdate self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getVel(self)


    def getRotVel(self):
        """getRotVel(ArClientHandlerRobotUpdate self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getRotVel(self)


    def getLatVel(self):
        """getLatVel(ArClientHandlerRobotUpdate self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getLatVel(self)


    def haveStateOfCharge(self):
        """haveStateOfCharge(ArClientHandlerRobotUpdate self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_haveStateOfCharge(self)


    def getStateOfCharge(self):
        """getStateOfCharge(ArClientHandlerRobotUpdate self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getStateOfCharge(self)


    def haveVoltage(self):
        """haveVoltage(ArClientHandlerRobotUpdate self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_haveVoltage(self)


    def getVoltage(self):
        """getVoltage(ArClientHandlerRobotUpdate self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getVoltage(self)


    def getTemperature(self):
        """getTemperature(ArClientHandlerRobotUpdate self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getTemperature(self)


    def getStatus(self):
        """getStatus(ArClientHandlerRobotUpdate self) -> char const *"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getStatus(self)


    def getMode(self):
        """getMode(ArClientHandlerRobotUpdate self) -> char const *"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getMode(self)


    def waitForStatus(self, status, timeout):
        """waitForStatus(ArClientHandlerRobotUpdate self, char const * status, long timeout) -> bool"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_waitForStatus(self, status, timeout)


    def waitForMode(self, mode, timeout):
        """waitForMode(ArClientHandlerRobotUpdate self, char const * mode, long timeout) -> bool"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_waitForMode(self, mode, timeout)

ArClientHandlerRobotUpdate_swigregister = _ArNetworkingPy.ArClientHandlerRobotUpdate_swigregister
ArClientHandlerRobotUpdate_swigregister(ArClientHandlerRobotUpdate)

# This file is compatible with both classic and new-style classes.


